09Java 集合类篇


集合类

java.util提供的,集合类可称为容器,集合的长度是可变的(动态长度),集合存放的是对象的引用

Collection接口

Collection接口不能直接使用,但提供了添加元素、删除元素、管理元素的方法

常用方法

修饰符 方法 说明
void add(E e) 添加指定对象
void remove(Object o) 指定对象在集合中移除
boolean isEmpty() 判断集合是否为空
int size() 获取集合中的个数
Iterator<E> iterator() 集合迭代器
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo {
    public static void main(String[] args) {
        Collection DcArray = new ArrayList();

        System.out.println("1集合是否为空?"+DcArray.isEmpty());

        DcArray.add("你好世界!");
        DcArray.add(233);
        DcArray.add(new Object());
        DcArray.add(3.14);

        System.out.println("2集合是否为空?"+DcArray.isEmpty());

        System.out.println("3集合长度:"+DcArray.size());

        DcArray.remove(3.14);

        System.out.println("4集合长度:"+DcArray.size());

        //Iterator 集合迭代器
        System.out.println("5遍历集合内容:");
        Iterator it = DcArray.iterator();
        //迭代循环有元素,则返回true循环。hasNext()
        while(it.hasNext()){
            //返回迭代下一元素。next();
            Object o = it.next();
            System.out.println(o);
        }

    }
}

运行结果

1集合是否为空?true
2集合是否为空?false
3集合长度:4
4集合长度:3
5遍历集合内容:
你好世界!
233
java.lang.Object@7530d0a

List集合

List集合像列表清单,它允许元素重复,但各个元素的顺序就是对象插入的顺序

List接口及实现类

List接口 继承了 Collection接口,因此也有父接口的方法

方法

修饰符 方法 说明
E get(int index) 获取指定索引的元素
E set(int index , Object obj) 将集合中指定索引位置的对象修改为指定的对象
boolean add(int index , Object obj) 指定位置插入数据

实现类

List接口常用的类有 ArrayList 与 LinkedList类

Class ArrayList<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.ArrayList<E>

ArrayList类 动态数组

Collection DcArray = new ArrayList();

Class LinkedList<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.AbstractSequentialList<E>
java.util.LinkedList<E>

LinkedList类 链表结构保存对象

List  list = new LinkedList();

ArrayList与LinkedList的区别

ArrayList查找较快,但插入、删除对象的速度较慢

LinkedList查找较慢,但插入、删除对象的速度较快

以下代码 List集合对 对象的操作

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        //另个用法一样
//        List  list = new ArrayList();
        List  list = new LinkedList();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        //集合长度
        System.out.println("长度为:"+list.size());
        //集合获取索引值(2)
        System.out.println("get(2):"+list.get(2));
        //更该索引值(2)
        list.set(2,"cc");
        //删除索引值4
        list.remove(4);
        //中间插入
        list.add(1,"bb");
        list.add(null);

        //输出内容
        System.out.println("遍历集合:");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }
}

运行结果

长度为:5
get(2):c
遍历集合:
a
bb
b
cc
d
null

Set集合

Set集合中的对象不按特定的方式排序,只是单纯的把对象添加到集合中,但不能有重复对象,Set接口 继承了 Collection接口,因此也有父接口的方法

方法

修饰符 方法 说明
boolean contains(Object o) 集合包含指定元素,则返回 true
Iterator<E> iterator() 返回集合中的元素的迭代器

实现类

TreeSet类

Class TreeSet<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractSet<E>
java.util.TreeSet<E>

TreeSet类 实现了Set集合在遍历集合时按照自然顺序递增排序

被排序前提对象要实现 Comparable接口

Set set = new TreeSet();

TreeSet类 提供方法

修饰符 方法 说明
E first() 返回集合中当前的第一个(最低)元素
E last() 返回集合中当前的最后(最高)元素
E comparator() 返回用于对该集合中的元素进行排序的比较器,或null
SortedSet<E> headSet(E toElement) 返回新的Set集合,新集合 toElement(不包含)之前所有对象
SortedSet<E> subSet(E fromElement, E toElement) 返回新的Set集合,其元素的范围从 fromElement (含)到 toElement
SortedSet<E> tailSet(E fromElement) 返回此组件的元素大于或等于 fromElement的部分的视图

TreSet类 对象的存储、输出以及方法的使用

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Demo {
    public static void main(String[] args) {
        Set set = new TreeSet();

        Student s = new Student(1 , 20 , "小明");
        Student s2 = new Student(2 , 22 , "小红");
        Student s3 = new Student(3 , 22 , "小军");
        Student s4 = new Student(4 , 24 , "小张");
        Student s5 = new Student(3 , 21 , "张三");
        Student s6 = new Student(9 , 23 , "李四");

        set.add(s);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        set.add(s6);
        set.add(s6);//重复,则无效
//        set.add(null); 异常

        System.out.println("集合总数为:"+set.size());

        System.out.println("返回集合第一个元素:"+((TreeSet) set).first());

        System.out.println("返回集合最后一个元素:"+((TreeSet) set).last());

        System.out.println("排序比较结果为:"+((TreeSet) set).comparator());

        System.out.println("\n输出集合:");
        Iterator it = set.iterator();
        //如果迭代有更多的元素,则true
        while(it.hasNext()){
            //next() 会自动调用对象的 toString()方法
            System.out.println(it.next());
        }

        //测试headSet()方法
        System.out.println("\n测试方法2");
        //截止至s4对象位置
        it = ((TreeSet) set).headSet(s4).iterator();
        while(it.hasNext()){
            //next() 会自动调用对象的 toString()方法
            System.out.println(it.next());
        }

        //测试subSet()方法
        System.out.println("\n测试方法3");
        //指定对象范围s ,s3
        it = ((TreeSet) set).subSet(s , s3).iterator();
        while(it.hasNext()){
            //next() 会自动调用对象的 toString()方法
            System.out.println(it.next());
        }

        //测试stailSet()方法
        System.out.println("\n测试方法4");
        //从s4对象位置开始排序
        it = ((TreeSet) set).tailSet(s4).iterator();
        while(it.hasNext()){
            //next() 会自动调用对象的 toString()方法
            System.out.println(it.next());
        }

    }
}


class Student implements Comparable{
    int id;
    int age;
    String name;

    //实例对象时获取的参数(信息)
    public Student(int id , int age , String name){
        super();
        this.id = id;
        this.age = age;
        this.name = name;
    }

    //迭代输出的信息
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    //迭代排序用到的方法
    @Override
    public int compareTo(Object o) {
        Student stt;
        if (o instanceof Student){
            stt = (Student)o;
        }else{
            //传入的参数比本身小,则-1
            return -1;
        }

        //如果相同则返回0

        /*
        *
        * 排序的值尽可能保持 唯一
        * 如唯一的id
        *
        * */

        //按照age排序的顺序(重复会被覆盖掉)
//        int tmp = this.age - stt.age;

        //按照id排序的顺序
        int tmp = this.id - stt.id;
        if(tmp != 0){
            //Math.abs() 绝对值
            //差值 除以本身 绝对值,结果只有 1 或 -1值
            tmp = tmp / Math.abs(tmp);
        }
        return tmp;
    }
}

运行结果

集合总数为:5
返回集合第一个元素:Student{id=1, age=20, name='小明'}
返回集合最后一个元素:Student{id=9, age=23, name='李四'}
排序比较结果为:null

输出集合:
Student{id=1, age=20, name='小明'}
Student{id=2, age=22, name='小红'}
Student{id=3, age=22, name='小军'}
Student{id=4, age=24, name='小张'}
Student{id=9, age=23, name='李四'}

测试方法2
Student{id=1, age=20, name='小明'}
Student{id=2, age=22, name='小红'}
Student{id=3, age=22, name='小军'}

测试方法3
Student{id=1, age=20, name='小明'}
Student{id=2, age=22, name='小红'}

测试方法4
Student{id=4, age=24, name='小张'}
Student{id=9, age=23, name='李四'}

HashSet类

Class HashSet<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractSet<E> Class HashSet<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractSet<E>

不能更改唯一值否则哈希表的唯一地址会错误,也能被删除!!

用HashSet存储的对象,应该重写以下两方法 hashCode()方法存哈希、equals()哈希地址判断

HashSet类 对象的存储、输出以及方法的使用

Set set = new HashSet();
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;

public class Demo2 {
    public static void main(String[] args) {
        Set set = new HashSet();

        Person p1 = new Person(1,"小明");
        Person p2 = new Person(2,"小红");
        Person p3 = new Person(3,"小军");
        Person p4 = new Person(4,"小张");
        Person p5 = new Person(5,"小海");
        Person p6 = new Person(6,"小明");

        set.add(p1);//首位位置里的id:9

        p1.id = 9;
        set.add(p1);//最后位置里的id:9

        set.add(p1);//添加无效
        set.add(p2);
        set.add(p3);
        set.add(p4);
        set.add(p5);
        set.add(p6);

        System.out.println("遍历数组:");
        Iterator in = set.iterator();
        while (in.hasNext()){
            System.out.println(in.next());
        }
    }
}

class Person{
    int id ;
    String name;

    public Person(int id , String name){
        super();
        this.id = id ;
        this.name = name;
    }

    //输出对象的值
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    //比较哈希值的地址
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Person)) {
            return false;
        }
        Person person = (Person) o;
        return id == person.id;
    }

    //根据hash返回哈希值
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

运行结果:

遍历数组:
Person{id=9, name='小明'}
Person{id=2, name='小红'}
Person{id=3, name='小军'}
Person{id=4, name='小张'}
Person{id=5, name='小海'}
Person{id=6, name='小明'}
Person{id=9, name='小明'}

HashSet集合 可能情况:

集合中不会保存相同的对象

同一个哈希地址可以存放多个不同对象

Map集合

Map集合没有 Collection接口 ,提供了 key (键)到 value(值)的映射。Map中不能有相同的 key (键),每个key (键)只能映射一个 value(值),key (键)决定了存储对象在映射中的存储位置

Map接口提供的方法

修饰符 方法 说明
V put(K key , V value) 将键值数据存入Map中
boolean containsKey(Object key) 查找Map中是否存在指定 键
boolean containsValue(Object value) 查找Map中是否存在指定 值
V get(Object key) 通过 键,获取 值
Set<K> keySet() 返回集合所有 key (键)对象 形成的Set集合
Collection<V> values() 返回集合所有 value(值)对象 形成的Collection集合

实现类

Class HashMap<K,V>

java.lang.Object
java.util.AbstractMap<K,V>
java.util.HashMap<K,V>

散列码 键值对速度更快,允许null对象,无序存储,但添加、删除快

Map<K , V> m = new HashMap<K , V>();

Class TreeMap<K,V>

java.lang.Object
java.util.AbstractMap<K,V>
java.util.TreeMap<K,V>

树状 键值对存放有序,不允许null对象,映射关系有一定的顺序,Key(键)不支持对象,数值,null!!

Map<K , V> m = new TreeMap<K , V>();
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Map map = new HashMap();
//        Map map2 = new TreeMap();

        //添加数据
        map.put("no1" , "no1字符串");
        map.put(12 , "12数值");
        map.put(12.3, "12.3单精度");
        map.put(null , null);
        map.put(new Object() , "obj对象");

        System.out.println("Map集合总数为:"+ map.size());

        System.out.println("在Map集合中 查找12的键 是否存在?"+map.containsKey(12));

        System.out.println("在Map集合中 查找 obj的值 是否存在?"+map.containsValue("obj"));

        System.out.println("\n遍历Map集合:");
        //以Set集合的形式获取所有对象Key对象
        Set set = map.keySet();
        Iterator it = set.iterator();
        while (it.hasNext()){
            //获取 键
            Object K = it.next();
            //通过 键 获取值 并输出
            System.out.println("K:"+K+"\tV:"+map.get(K));
        }

        System.out.println("\n遍历值:");
        //以Collection形式获取对象值
        Collection con = map.values();
        Iterator it2 = con.iterator();
        while (it2.hasNext()){
            System.out.println(it2.next());
        }
    }
}

运行结果

Map集合总数为:5
在Map集合中 查找12的键 是否存在?true
在Map集合中 查找 obj的值 是否存在?false

遍历Map集合:
K:null    V:null
K:java.lang.Object@10f87f48    V:obj对象
K:no1    V:no1字符串
K:12.3    V:12.3单精度
K:12    V:12数值

遍历值:
null
obj对象
no1字符串
12.3单精度
12数值

迭代器

迭代器用来遍历集合中的元素

方法

修饰符 方法 说明
boolean hasNext() 迭代具有更多元素,则返回 true
E next() 返回迭代中的下一个元素
void remove() 从底层集合中删除此迭代器返回的最后一个元素

文章作者: 柏竹
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 柏竹 !
评论
  目录