Java集合详解

最新推荐文章于 2024-10-16 16:34:42 发布

小心翼翼L

最新推荐文章于 2024-10-16 16:34:42 发布

阅读量371

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_52266903/article/details/127639074

版权

一：单列集合Collection

List接口（单列集合Collection的子接口一）

List中常用方法和三个实现类

Collection集合遍历三种方法

Set接口（单列集合Collection的子接口二）

集合按照存储结构可以分为两大类，单列集合Collection和双列集合Map

必须清楚的概念：这里的有序和无序不是指集合中的排序，而是指是否按照元素添加的顺序来存储对象。

一：单列集合Collection

Collection接口的方法

public class ListTest {
    public static void main(String[] args) {
        ListTest listTest=new ListTest();
        listTest.show();
    }
//Collection接口的常用方法
    public void show(){
        Collection coll =new ArrayList();//多态的向上转型 接口 对象名=new 实现类()
        //1.add()添加元素
        coll.add(001);
        coll.add(002);
        coll.add(false);
        //4.contains(Object o):判断集合中是否包含指定的元素
        boolean IsOrFalse = coll.contains(002);
        System.out.println(IsOrFalse);
        System.out.println(coll.contains(false));
        //5.isEmpty()判断集合是否为空
        boolean IsOrFalse1=coll.isEmpty();
        System.out.println(IsOrFalse1);
        //7.remove(Object obj):删除指定的元素
        boolean IsOrFalse2=coll.remove(003);
        System.out.println(IsOrFalse2);
        //8.int size()返回元素的个数
        System.out.println("元素的个数是"+coll.size());
        //2.addAll(Collection c)将集合c所有元素添加到指定集合中
        Collection coll2 =new ArrayList();
        coll2.add("新增加");
        coll.addAll(coll2);
        //6.Iterator迭代器方式循环
        Iterator iterator = coll.iterator();//获取Iterator对象
        while(iterator.hasNext()){//判断是否存在下一个元素
            System.out.println(iterator.next());
        }
        //3.清空集合里所有元素，将长度变为0
        coll2.clear();//用的是2.addAll()测试中。新创建的对象
    }
}

List接口（单列集合Collection的子接口一）

List接口中的元素有序可重复(list是按照元素的添加顺序来存储对象，因此是有序的)，可通过索引访问集合中指定元素。List接口中不但继承了Collection的全部方法还拥有特有的方法

    //测试List中的常用方法，Arraylist实现类可以实现list接口和list父接口Collerction的方法
    public void show() {
        List list = new ArrayList();//向上转型
        list.add("a001");
        list.add("a002");
        //1.void add(int index, Object ele):在index位置插入元素,索引从0开始
        list.add(0, "BB");
        System.out.println(list);
        //2.Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));
        //3.int indexOf(Object obj):返回元素首次出现的位置。如果不存在，返回-1.
        System.out.println(list.indexOf(4567));
        //4.int lastIndexOf(Object obj):返回元素在当前集合中最后出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));
        //5.Object remove(int index):删除，并返回index索引处的元素
        System.out.println(list.remove(0));
        //6.Object set(int index, Object ele):将index索引处替换成新的element对象，并返回被替换的旧元素
        Object name=list.set(1,"CC");
        System.out.println("被替换的旧元素"+name);
        //截取fromlndex(包含)到tolndex(不包含)处的集合元素，组成新的子集
        List subList = list.subList(0, 1);
        System.out.println(subList);
    }
}

List中常用方法和三个实现类

1.增：add(Object obj)
2.删：remove(int index) / remove(Object obj)
3.改：set(int index, Object ele)
4.查：get(int index)
5.插：add(int index, Object ele)
6.长度：size()

（1）ArrayList：底层数据结构是数组，查询快，增删效率低，线程不安全，效率高，可以存储重复元素。

（2）LinkedList 底层数据结构是双向链表，查询慢，增删效率高，线程不安全，效率高，可以存储重复元素

（3）Vector:底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素

Collection集合遍历三种方法

//第一种:迭代器遍历,集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
Iterator iterator = coll.iterator();//获取Iterator对象后会有一个游标在第一个元素之前，coll是集合对象名
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
    //next():①指针下移 ②将下移以后集合位置上的元素返回
    System.out.println(iterator.next());
}

//迭代器遍历时删除集合中"Tom"，遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
   Object obj = iterator.next();
   if("Tom".equals(obj)){
   iterator.remove();。//使用的是迭代器对象的remove()方法，使用集合的remove会报错
  }
 }

//第二种forEach遍历
//for(集合元素的类型 局部变量 : 集合对象)
for(Object obj : coll){
    System.out.println(obj);
}
 //方式三：普通for循环
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}

Set接口（单列集合Collection的子接口二）

Set存储无序不可重复(根据对象的哈希值得到存储位置，不是添加的顺序)的数据，它就像一个罐子，依次把多个对象“丢进”Set集合。,但不会记住添加的顺序。不予许相同的元素，Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

HashSet实现类

HashSet是Set接口的一个实现类：集合元素可以是null(null也只能存储一次，因为set中元素不可重复),仅仅是HashSet的判断元素相同标准:两个对象的equals()方法比较相等，并且两个对象的哈希码(方法返回值也相等)
无序不可重复的原因:hashCode方法(根据对象哈希值得到存储位置,无序指的是添加的顺序)，equals(判断是否有重复元素)
要存入HashSet的集合对象中的自定义类必须重写覆盖hashCode(),equals()两个方法，才能保证集合中元素不重复。在覆盖equals()和hashCode()方法时，要使相同对象的hashCode()方法返回相同值，覆盖equals()方法再判断其内容。为了保证效率，所以在覆盖hashCode()方法时，也要尽量使不同对象尽量返回不同的Hash码值。
当向HashSet结合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置（为什么HashSet 是如何保证不重复的）。也就是说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相等。不能保证元素的排列顺序，顺序有可能发生变化;集合元素可以是null，但只能放入一个null;

public class HashSetTest {
    public static void main(String[] args) {
        HashSetTest hashSetTest=new HashSetTest();
        hashSetTest.show();
    }
    private void show() {
        Set hashSet=new HashSet();
        hashSet.add(1);//Set无序(指的是添加顺序)不重复，根据哈希值确定存储位置
        hashSet.add("two");
        hashSet.add("one");
        hashSet.add(null);//可以存储null,添加两次集合中只是一个，因为不重复(equals判断是否重复)
        hashSet.add(null);
        System.out.println(hashSet);
    }
}

HashSet实现类存储值过程

LinkedHashSet实现类：

LinkedhashSet是HashSet的子类，不允许集合元素重复，是一个哈希表和链表的结合，且是一个双向链表(添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据)。对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以添加顺序保存的，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。

    private void show() {
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(129);
        set.add(new Person("lyj",12));//Person类中必须重写hashCode和equals方法,否则会出现重复的元素
        set.add(new Person("lyj",12));
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

TreeSet集合

1.向TreeSet中添加的数据，要求是相同类的对象。集合中没有重复的元素并且对元素进行排序。

2.自定义对象有两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）自然排序要求元素必须实现Compareable接口，并重写里面的compareTo()方法，元素通过比较返回的int值来判断排序序列，返回0说明两个对象相同，不需要存储；

比较器排序需要在TreeSet初始化是时候传入一个实现Comparator接口的比较器对象，或者采用匿名内部类的方式new一个Comparator对象，重写里面的compare()方法；

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Teacher("姓名1", 20));
        treeSet.add(new Teacher("姓名2", 21));
        treeSet.add(new Teacher("姓名3", 22));
        treeSet.add(new Teacher("姓名4", 20));
        System.out.println(treeSet);;
    }
}

//自然排序要求Treeset集合中存储的元素所在类必须实现Comparable接口并重写compareTo方法。
//默认已升序排序
class Teacher implements Comparable {
    String name;
    int age;
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Object o) {
        Teacher s = (Teacher) o;
        if (this.age - s.age > 0) {
            return 1;
        }
        if (this.age - s.age == 0) {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
}

@Test
//定制排序需要在TreeSet初始化是时候传入一个实现Comparator接口的比较器对象，或者采用匿名内部类的方式new一个Comparator对象，重写里面的compare()方法；
public void test2(){
    TreeMap map = new TreeMap(new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof User && o2 instanceof User){
                User u1 = (User)o1;
                User u2 = (User)o2;
                return Integer.compare(u1.getAge(),u2.getAge());
            }
            throw new RuntimeException("输入的类型不匹配！");
        }
    });
    User u1 = new User("Tom",23);
    User u2 = new User("Jerry",32);
    User u3 = new User("Jack",20);
    User u4 = new User("Rose",18);
    map.put(u1,98);
    map.put(u2,89);
    map.put(u3,76);
    map.put(u4,100);
    Set entrySet = map.entrySet();
    Iterator iterator1 = entrySet.iterator();
    while (iterator1.hasNext()){
        Object obj = iterator1.next();
        Map.Entry entry = (Map.Entry) obj;
        System.out.println(entry.getKey() + "---->" + entry.getValue());
    }
}

List和Set总结

（1）List,Set都是继承自Collection接口，List可通过下标来访问，而Set不能

（2）List特点：元素有放入顺序，元素可重复，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）

双列集合Map

Map用于保存具有映射关系的数据，Map里保存着两组数据：键对象key和值对象Value,它们都可以使任何引用类型的数据，但key不能重复。所以通过指定的key就可以取出对应的value。Map中映射关系是一对一。

Object put(Object key,Object value)将指定key-value添加到(或修改)当前map对象中(Map键具有唯一性，添加已经存在的键值元素时会覆盖)
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

@Test
public void test1(){
    Map map = new HashMap();
    
    //1.Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
    map.put("AA",11);
    map.put(45,34);
    map.put("BB",22);
    
    map.put("AA",00);//如果有相同的key，会覆盖
    System.out.println(map);//{AA=0, BB=22, 45=34}

    //2.void putAll(Map m):将m中的所有key-value对存放到当前map中
    Map map1 = new HashMap();
    map1.put("CC",33); 
    map1.put("DD",44);
    map.putAll(map1);
    System.out.println(map);//{AA=0, BB=22, CC=33, DD=44, 45=34}

    //3.Object remove(Object key)：移除指定键的key-value对，并返回value；如果没有该key就返回null
    Object value = map.remove("CC");
    System.out.println(value);//33

    //4.Object get(Object key)：获取指定key对应的value
    Object obj = map.get("AA");
    System.out.println(obj);//0

    //5.boolean containsKey(Object key)：是否包含指定的key
    System.out.println(map.containsKey("AA"));//true
    System.out.println(map.containsKey("EE"));//flase

    //6.boolean containsValue(Object value)：是否包含指定的value
    System.out.println(map.containsValue(22));//true

    //7.void clear()：清空当前map中的所有数据
    map.clear();
    System.out.println(map.size());//0
    System.out.println(map);//{}

    //8.boolean isEmpty()：判断当前map是否为空
    System.out.println(map.isEmpty());//true
}

Map集合遍历

//1.迭代器遍历Map集合，需要先将Map集合转换为Iterator接口对象，然后进行遍历。
//有两种将Map集合转换为Iterator接口对象的方法(KeySet(),entrySet())
@Test
public void test2(){
    Map map = new HashMap();
    map.put("AA",11);
    map.put("BB",22);
    map.put("CC",33);
   
     
    //方法一：Set keySet()：返回所有key构成的Set集合
    Set set = map.keySet();//先将Map集合中所有键对象转换为Set单列集合
    Iterator iterator = set.iterator();//包含键对象的Set集合转换为Iterator接口对象
    while(iterator.hasNext()){ //遍历
        Object obj = iterator.next();
        System.out.println(obj+"="+map.get(obj));//通过key获取到value
    }

  

    //方法二：Set entrySet()：返回所有key-value对构成的Set集合，集合中的每个元素是Entry类型
    Set entrySet = map.entrySet();//将Map集合中键值对作为一个整体返回为Set集合
    Iterator iterators = entrySet.iterator();//将包含键值对对象的Set集合转换为Iterator接口对象
    while(iterators.hasNext()){//遍历
        Object obj = iterators.next();
        Map.Entry entry = (Map.Entry)obj;//获取集合中键值对映射关系
        System.out.println(entry.getKey()+"="+entry.getValue());//entry.getKey()获取Entry中的键，entry.getValue()是获取Entry的值)
    }
    
    //方法三：Collection values()：返回所有value构成的Collection集合，遍历value
    Collection values = map.values();
    for(Object obj : values){
        System.out.println(obj);
    }

     //方法四：加强for循环
     for(Map.Entry<String,Object> entry : map.entrySet()){
        String mapKey = entry.getKey();
        Object mapValue = entry.getValue();
        System.out.println(mapKey+":"+mapValue);
    }
}

Collections工具类

操作Collection(Set,List)和Map集合的工具类

/*
static void reverse(List)：反转 List 中元素的顺序
static void shuffle(List)：对 List 集合元素进行随机排序
static void sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
static void sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
static void swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

static Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
static Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
static Object min(Collection)
static Object min(Collection，Comparator)
 int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值*/
private void show() {
    List list = new ArrayList();
    list.add(123);
    list.add(43);
    list.add(765);
    list.add(-97);
    list.add(0);
    System.out.println("反转前:"+list);
    Collections.reverse(list);//Static静态方法，类名.方法名调用
    System.out.println("反转后:"+list);
    //static void shuffle(List)：对 List 集合元素进行随机排序
    Collections.shuffle(list);
    System.out.println("随机排序后:"+list);
    //static void sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
    Collections.sort(list);
    System.out.println("升序排序后:"+list);
    //static void swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
    Collections.swap(list,1,2);//list集合中元素下标从0开始
    System.out.println("交换元素后:"+list);
   //static Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
    System.out.println("返回集合中最大的元素"+Collections.max(list));
    //static Object min(Collection)返回最小的元素
    System.out.println("返回集合中最小的元素"+Collections.min(list));
  // boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
  boolean IsOrFalse = Collections.replaceAll(list,-97,97);
    System.out.println("替换是否成功"+IsOrFalse);
}