编程语言
首页 > 编程语言> > JavaSE_第十二章:集合

JavaSE_第十二章:集合

作者:互联网

JavaSE学习历程

第一章:Java初识
第二章:Java语言基础
第三章:选择结构与分支结构
第四章:循环结构
第五章:方法/函数
第六章:数组
第七章:面向对象
第八章:三大特性
第九章:三个修饰符
第十章:接口
第十一章:常用类

第十二章:集合

1 集合的概念

什么是集合

  • 概念:对象的容器,定义了对多个对象进行操作的常用方法.可实现数组的功能.

集合和数组区别

  • 数组长度固定,集合长度不固定
  • 数组可以存储基本类型和引用类型,集合只能存储引用类型
  • 集合位置:java.util.*;

2 Collection体系集合

Collection父接口:

  • 特点:代表一组任意类型的对象,无序、无下标。

常用方法:

方法描述
boolean add(Object obj)添加一个对象数据
boolean addAll(Collection c)将一个集合中的所有对象添加到此集合中
void clear()清空此集合中的所有对象
boolean contains(Object o)检查此集合中是否包含o对象
boolean equals(Object o)比较此集合是否与指定对象相等
boolean isEmpty()判断此集合是否为空
boolean remove(Object o)在此集合中移除o对象
int size()返回此集合中的元素个数
Object[] toArray()将此集合转换成数组

案例

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * @Classname Demo01
 * @Description TODO:1、创建多个Student对象,使用集合Collection进行保存,使用Iterator和增强for进行遍历输出,并输出集合中有多少个值。
 * @Date 2021/03/24 10:46
 * @Created by xx
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建集合保存对象
        Collection con = new ArrayList();
        con.add(new Student("张三",20));
        con.add(new Student("李四",23));
        con.add(new Student("王五",25));
        con.add(new Student("赵六",27));

        //使用增强for遍历:name与age类型不一致--->obje
        for (Object object:con) {
            Student s = (Student)object;
            //使用重写后的toString方法
//            System.out.println(object);
            System.out.println(s);
        }

        System.out.println("==================================");
        //使用Iterator迭代器遍历
        Iterator iterator = con.iterator();
        while (iterator.hasNext()){
            Student s = (Student) iterator.next();
            System.out.println(s);
        }
        System.out.println("集合共"+con.size()+"个值");
        System.out.println("========================================");


        /**
         * 2、创建多个Student对象,使用集合Collection进行保存,删除后遍历输出,在清空,后判断是否为空。
         * */
        //删除一个值
        Iterator it = con.iterator();
        while (it.hasNext()){
            Student s = (Student)it.next();
            if (s.getName().equals("王五")) {
                it.remove();
            }
        }
        for (Object obj:con) {
            Student s = (Student)obj;
            System.out.println(s);
        }
        System.out.println("================================");

        //清空集合
//        con.clear();
        //移除本身--->清空集合
        con.removeAll(con);
        //判断是否为空
        System.out.println("集合是否为空:"+(con.isEmpty()?"集合为空":"集合不为空"));

        System.out.println("===================================================");
        List list = new ArrayList();
        list.add("zs");
        list.add("ls");
        list.add(7);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));

        }
    }
}

/*
运行结果:
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
集合共4个值
========================================
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='赵六', age=27}
================================
集合是否为空:集合为空
===================================================
zs
ls
7
*/
/**
 * @Classname Student
 * @Description TODO:
 * @Date 2021/03/24 12:54
 * @Created by xx
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        //判断地址
        if (this == obj) {
            return true;
        }
        //判断类型
        if (obj instanceof Student) {
            Student s = (Student) obj;
            if (this.name.equals(s.getName())&& this.age == s.getAge()) {
                return true;
            }
        }
        return false;
    }
}

注:遍历的同时不能使用集合删除方法,否则会出现并发修改异常,可以使用迭代器的删除方法.

3 List接口与实现类

3.1 List接口

  • 特点:有序、有下标、元素可重复。
  • 继承Collection接口。

常用方法:

方法描述
void add(int index, Object o)在index位置插入对象o。
boolean addAll(int index, Collection c)将一个集合中的元素添加到此集合中的index位置。
Object get(int index)返回集合中指定位置的元素。
List subList(int fromIndex, int toIndex)返回fromIndex和toIndex之间的集合元素。

案例:List集合保存对象

/**
 * @Classname Demo3
 * @Description TODO:3、创建多个Student对象,使用集合List集合保存,进行添加、以下标添加、以下标获取对象并输出,以下标删除,以下标修改值。add(int index, Object o)
 * @Date 2021/03/24 12:54
 * @Created by xx
 */
public class Demo3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(0,new Student("张三",20));
        list.add(1,new Student("李四",23));
        list.add(2,new Student("王五",25));
        list.add(3,new Student("赵六",27));

        //下标获取对象并输出
        for (int i = 0; i < list.size(); i++) {
            Student s = (Student) list.get(i);
            System.out.println(s);
        }
        System.out.println("==================================");

        //通过下标删除对象
        list.remove(1);
        for (int i = 0; i < list.size(); i++) {
            Student s = (Student) list.get(i);
            System.out.println(s);
        }
        System.out.println("==================================");

        //通过下标修改对象
        list.set(2,new Student("孙七",18));
        Iterator ite = list.iterator();
        while (ite.hasNext()){
            Student s = (Student) ite.next();
            System.out.println(s);
        }
        System.out.println("==================================");

        //判断是否存在
        Student s1 = new Student("王五",25);
        System.out.println("是否存在:"+(list.contains(s1)?"存在":"不存在"));
    }
}

/*
运行结果:
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
==================================
是否存在:存在

Process finished with exit code 0

*/

3.2 List实现类

3.2.1 ArrayList

  • 数组结构实现,查询快,增删慢.
  • JDK1.2版本、线程不安全

案例:ArraysList集合保存对象

/**
 * @Classname TestArrayList
 * @Description TODO:4、创建多个Student对象,使用集合ArraysList集合保存,进行添加、以下标添加、以下标获取对象并输出,以下标删除,以下标修改值。
 * @Date 2021/03/24 15:35
 * @Created by xx
 */
public class TestArrayList {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();

        //以下标添加对象
        arrayList.add(0,new Student("张三",20));
        arrayList.add(1,new Student("李四",23));
        arrayList.add(2,new Student("王五",25));
        arrayList.add(3,new Student("赵六",27));

        //以下标获取对象并输出
        System.out.println(arrayList.get(1));
        System.out.println("===================");

        //以下标删除对象
        arrayList.remove(2);
        for (Object object:arrayList) {
            Student s = (Student)object;
            System.out.println(s);
        }
        System.out.println("===================");

        //以下标修改对象
        arrayList.set(0,new Student("孙七",18));
        System.out.println(arrayList.get(0));
        System.out.println("===================");
    }
}

/*
运行结果:
Student{name='李四', age=23}
===================
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='赵六', age=27}
===================
Student{name='孙七', age=18}
===================
*/

3.2.2 LinkedList

  • 链表结构实现,增删快,查询慢.
  • JDK1.2版本,线程不安全.

案例:LinkedList保存对象数据。

/**
 * @Classname TestLinkedList
 * @Description TODO:5、创建多个Student对象,使用集合LinkedList集合保存,进行添加、以下标添加、以下标获取对象并输出,以下标删除,以下标修改值。使用addLast/addFirst/removeFirst/removeLast等方法
 * @Date 2021/03/24 15:43
 * @Created by xx
 */
public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();

        //以下标添加对象
        linkedList.add(0,new Student("张三",20));
        linkedList.add(1,new Student("李四",23));
        linkedList.add(2,new Student("王五",25));
        linkedList.add(3,new Student("赵六",27));

        //以下标获取对象
        System.out.println(linkedList.get(0));
        System.out.println("==================================");

        //以下标删除对象
        linkedList.remove(1);
        for (int i = 0; i < linkedList.size(); i++) {
            Student s = (Student) linkedList.get(i);
            System.out.println(s);
        }
        System.out.println("==================================");

        //以下标修改对象
        linkedList.set(2,new Student("孙七",18));
        ListIterator ite = linkedList.listIterator();
        while (ite.hasNext()){
            Student s = (Student) ite.next();
            System.out.println(s);
        }
        System.out.println("==================================");


        //使用addLast/addFirst/removeFirst/removeLast等方法

        linkedList.addFirst(new Student("周八",28));
        linkedList.addLast(new Student("吴九",30));
        for (Object obj:linkedList) {
            Student s = (Student) obj;
            System.out.println(s);
        }
        System.out.println("==================================");

        //移除第一个与最后一个对象
        linkedList.removeFirst();
        linkedList.removeLast();

        for (int i = 0; i < linkedList.size(); i++) {
           Student s = (Student) linkedList.get(i);
            System.out.println(s);
        }
    }
}

/*
运行结果:
Student{name='张三', age=20}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
==================================
Student{name='周八', age=28}
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
Student{name='吴九', age=30}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}

*/

ArrayList和LinkedList区别:

  • ArrayList存储结构是数据,查找、遍历效率高。
  • LinkedList存储结构是双向链表,删除、添加效率高。

3.2.3 Vector

数组结构实现,查询快,增删慢.
JDK1.0版本,线程安全,运行效率比ArrayList较慢.

案例:使用Vector保存数据

import java.util.ListIterator;
import java.util.Vector;

/**
 * @Classname TestVector
 * @Description TODO:LinkedList集合保存对象数据
 * @Date 2021/03/26 17:52
 * @Created by xx
 */
public class TestVector {
    public static void main(String[] args) {

        Vector vector = new Vector();

        //以下标添加对象
        vector.add(0, new Student("张三", 20));
        vector.add(1, new Student("李四", 23));
        vector.add(2, new Student("王五", 25));
        vector.add(3, new Student("赵六", 27));

        //以下标获取对象
        System.out.println(vector.get(0));
        System.out.println("==================================");

        //以下标删除对象
        vector.remove(1);
        for (int i = 0; i < vector.size(); i++) {
            Student s = (Student) vector.get(i);
            System.out.println(s);
        }
        System.out.println("==================================");

        //以下标修改对象
        vector.set(2, new Student("孙七", 18));
        ListIterator ite = vector.listIterator();
        while (ite.hasNext()) {
            Student s = (Student) ite.next();
            System.out.println(s);
        }
        System.out.println("==================================");
    }
}

/*
运行结果:
Student{name='张三', age=20}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
==================================2
*/

4 Set接口与实现类

4.1Set接口

  • 特点:无序,无下标,元素不可重复.
  • 方法:全部继承自Collection中的方法.
  • 使用foreach循环遍历:
    for(数据类型 局部变量名:集合名){
    //循环内部的局部变量,代表当次循环从集合中取出的对象.
    }

案例:使用Set接口保存不重复数据.

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * @Classname TestSet
 * @Description TODO:
 * @Date 2021/03/25 09:48
 * @Created by xx
 */
public class TestSet {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        Scanner input = new Scanner(System.in);
        System.out.println("请输入需要存储的字符串");
        String s = input.next();

        //字符串转字符数组
        char[] c = s.toCharArray();

        //大写转小写

//        char a= 'A';//65---a--->97
//        int i =a;
//        System.out.println(i);

        //大写转小写;小写转大写
        for (int i = 0; i < c.length-1; i++) {
            if (c[i]>='A'&&c[i]<='Z'){
                c[i] += 32;
            }else if (c[i]>='a'&&c[i]<='z'){
                c[i] -= 32;
            }
        }

        for (Character ch:c) {
            //字节转字符串
            set.add(ch.toString());
        }

        //打印去除重复元素后的集合
        System.out.println(set);

    }
}

/*
运行结果:
请输入需要存储的字符串
jwspgjeoigjslanglkajg
[A, E, G, g, I, J, K, L, N, O, P, S, W]
*/

4.2 Set实现类

4.2.1 HashSet

  • 基于HashCode实现元素步重复.
  • 当存入元素的哈希码相同时,会调用==或equals进行确认,结果为tru,拒绝后者存入.

案例:HashSet实现不可插入重复的对象(对象属性相同为同一对象)

import java.util.HashSet;

/**
 * @Classname TestHashSet
 * @Description TODO:HashSet实现不可插入重复的对象(对象属性相同为同一对象)
 * @Date 2021/03/25 11:25
 * @Created by xx
 */
public class TestHashSet {
    public static void main(String[] args) {
        HashSet<Student> hashSet = new HashSet<Student>();
        hashSet.add(new Student("张三",20));
        hashSet.add(new Student("李四",23));
        hashSet.add(new Student("王五",25));
        hashSet.add(new Student("赵六",27));
        System.out.println("插入重复值前:"+hashSet);
        System.out.println("============");
        hashSet.add(new Student("李四",23));
        System.out.println("插入重复值后:"+hashSet);

    }
}

/*
运行结果:
插入重复值前:[Student{name='张三', age=20}, Student{name='李四', age=23}, Student{name='赵六', age=27}, Student{name='王五', age=25}]
============
插入重复值后:[Student{name='张三', age=20}, Student{name='李四', age=23}, Student{name='赵六', age=27}, Student{name='王五', age=25}]
*/

注意:

  • 根据hashcode计算保存的位置,如果此位置为空,则直接保存,如果不为空执行第二步。
  • 再执行equals方法,如果equals方法为true,则认为是重复,否则,形成链表。
  • JDK1.8之后引入红黑树,提高效率。

4.2.2 LinkedHashSet

  • 链表实现HashSet,按照链表存储,保留元素的插入顺序.

4.2.3 TreeSet

  • 基于排列顺序实现元素不重复。
  • 实现了SortedSet接口,对集合元素自动排序。
  • 元素对象的类型必须实现Comparable接口,指定排序规则(自然排序)。
  • 通过CompareTo方法确定是否为重复元素。

案例:treeSet集合实现有序插入

import java.util.Comparator;
import java.util.TreeSet;

/*
 * @Classname TestTreeSet
 * @Description TODO:treeSet集合实现有序插入
 * @Date 2021/03/25 14:33
 * @Created by xx
 */
 
public class TestTreeSet {
    public static void main(String[] args) {
        //使用comparator比较器实现比较
        /*TreeSet<Student> treeSet = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.getName().hashCode()- o2.getName().hashCode();
                int i1 = o1.getAge().hashCode()- o2.getAge().hashCode();
                return i != 0 ? i : i1;
            }
        });*/

        //Student类实现comparable接口--->实现比较

        TreeSet<Student> treeSet = new TreeSet<Student>();

        treeSet.add(new Student("张三",20));
        treeSet.add(new Student("赵六",28));
        treeSet.add(new Student("李四",23));
        treeSet.add(new Student("李四",23));
        treeSet.add(new Student("王五",25));
        treeSet.add(new Student("赵六",27));

        for (Student stu:treeSet) {
            System.out.println(stu);
        }
    }
}

/*
运行结果:
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
Student{name='赵六', age=28}
*/

注:元素必须要实现Comparable接口,compareTo()方法返回值为0,认为是重复元素。

5 Map接口与实现类

5.1 Map接口的特点

  • 用于存储任意键值对(key-Value).
  • 键:无下标,不重复(唯一).
  • 值:无下标,可以重复.

5.2 Map接口

特点: 称为“映射”存储一对数据(Key-Value),键不可重复,值可以重复

常用方法:

方法名描述
V put(K key,V value)将对象存入到集合中,关联键值。key重复则覆盖原值。
Object get(Object key)根据键获取对应的值。
Set keySet()返回所有key。
Collection values()返回包含所有值的Collection集合。
Set<Map.Entry<K,V>> entrySet()键值匹配的Set集合。

案例:map实现增删改查功能

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @Classname TestMap
 * @Description TODO:map实现增删改查功能
 * @Date 2021/03/25 15:34
 * @Created by xx
 */
public class TestMap {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();

        //增
        map.put("US", "美利坚合众国");
        map.put("EN", "大不列颠及北爱尔兰联合王国");
        map.put("JP", "日本国");
        map.put("CN", "中华人民共和国");

        //查
        for (String key : map.keySet()) {
            System.out.println(map.get(key));
        }
        System.out.println("=======================");

        //删
        map.remove("JP");
        for (String key : map.keySet()) {
            System.out.println(map.get(key));
        }
        System.out.println("=======================");

        //改
        map.put("EN", "英国");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        System.out.println(entries);

    /*    for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey()+"---------"+entry.getValue());
    }*/
    }
}

/*
运行结果:
日本国
大不列颠及北爱尔兰联合王国
中华人民共和国
美利坚合众国
=======================
大不列颠及北爱尔兰联合王国
中华人民共和国
美利坚合众国
=======================
[EN=英国, CN=中华人民共和国, US=美利坚合众国]
*/

5.3 Map实现类

5.3.1 HashMap(重点)

  • JDK1.2版本,线程不安全,运行效率快。
  • 允许用null 作为key或是value。
  • 存储结构:哈希表。

案例:HashMap保存对象数据

public class TestHashMap {
	public static void main(String[] args) {
	
		//创建集合
		HashMap<Student, String> students=new HashMap<Student,String>();
		//刚创建hashmap之后没有添加元素 table=null   size=0 目的节省空间
		//1添加元素
		Student s1=new Student("张三", 18);
		Student s2=new Student("李四", 20);
		Student s3=new Student("王五", 22);
		students.put(s1, "北京");
		students.put(s2, "上海");
		students.put(s3, "杭州");
		//students.put(s3, "南京");
		students.put(new Student("王五", 22), "杭州");
		System.out.println("元素个数:"+students.size());
		System.out.println(students.toString());
		//2删除
//		students.remove(s1);
//		System.out.println("删除之后"+students.size());
		//3遍历
		System.out.println("--------keySet---------");
		//3.1使用keySet();
		for (Student key : students.keySet()) {
			System.out.println(key.toString()+"========="+students.get(key));
		}
		System.out.println("--------entrySet---------");
		//3.2使用entrySet();
		for (Map.Entry<Student, String> entry : students.entrySet()) {
			System.out.println(entry.getKey()+"---------"+entry.getValue());
		}
		//4判断
		System.out.println(students.containsKey(new Student("张三", 18)));
		System.out.println(students.containsValue("杭州"));
		
	}
}

5.3.2 TreeMap

实现了SortedMap接口(Map的子接口),可以对key自动排序,Key需实现Comparable接口。

案例演示:使用TreeMap保存数据。

public class TestTreeMap {
	public static void main(String[] args) {
		
		//新建集合(定制比较)
		TreeMap<Student, String> treeMap=new TreeMap<Student,String>();
		//1添加元素
		Student s1=new Student("张三", 18);
		Student s2=new Student("李四", 20);
		Student s3=new Student("王五", 22);
		treeMap.put(s1, "北京");
		treeMap.put(s2, "上海");
		treeMap.put(s3, "深圳");
		treeMap.put(new Student("王五", 22), "南京");
		System.out.println("元素个数:"+treeMap.size());
		System.out.println(treeMap.toString());
		//2删除
//		treeMap.remove(new Student("李四", 20));
//		System.out.println(treeMap.size());
		//3遍历
		//3.1使用keySet
		System.out.println("-----keySet()-------");
		for (Student key : treeMap.keySet()) {
			System.out.println(key+"-------"+treeMap.get(key));
		}
		System.out.println("------entrySet()--------");
		for(Map.Entry<Student, String> entry : treeMap.entrySet()) {
			System.out.println(entry.getKey()+"--------"+entry.getValue());
		}
		
		//4判断
		System.out.println(treeMap.containsKey(new Student("王五", 22)));
	}
}

5.3.3 其他实现类

Hashtable:

  • jdk1.0版本,线程安全,运行效率慢,不允许`null作为键值.
    Properties:
  • Hashtable的子类,要求key与value都是String.通常用于配置文件的读取.

6 泛型集合

6.1 泛型概念

概念:

  • Java泛型是JDK1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递.
  • 常见形式有泛型类,泛型接口,泛型方法.

语法:

  • <T,…> T称为类型占位符,表示一种引用类型.

优点:

  • 提高代码的重用性.
  • 防止类型转换异常,提高代码的安全性.

案例:

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

/**
 * @Classname TestList01
 * @Description TODO:
 * @Date 2021/03/24 08:36
 * @Created by xx
 */
public class TestList01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("World");
        list.add("Hello");
        list.add("Learn");
        list.remove("Hello");
        list.remove(0);
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }
//        for (String string:list) {
//            System.out.println(string);
//        }
        //for循环
        for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
            String string = (String) iterator.next();
            System.out.println(string);
        }

    }
}

/*
运行结果:
Hello
Learn
*/

1.泛型只能使用引用类型.2.不同泛型类型对象之间不能相互赋值.

6.2 泛型集合

  • 参数化类型,类型安全的集合,强制集合元素的类型必须一致.
  • 特点:
    • 编译时检查,而非运行时抛出异常.
    • 访问时,不必类型转换(拆箱).
    • 不同泛型之间引用不能相互赋值,泛型不存在多态.

案例:

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

/**
 * @Classname TestList01
 * @Description TODO:
 * @Date 2021/03/24 08:36
 * @Created by xx
 */
public class TestList01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("World");
        list.add("Hello");
        list.add("Learn");
        list.remove("Hello");
        list.remove(0);
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }
//        for (String string:list) {
//            System.out.println(string);
//        }
        //for循环
        for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
            String string = (String) iterator.next();
            System.out.println(string);
        }

    }
}

/*
运行结果:
zs
ls
==================
12
18
*/

7 Collections工具类

集合工具类,定义了除了存取之外的集合常用方法.

常用方法:

方法描述
public static void reverse(List<?> list)反转集合中元素的顺序
public static void shuffle(List<?> list)随机重置集合元素的顺序
public static void sort(List<T> list)升序排序(元素类型必须实现Comparable接口)
public static <T> int binarySearch( list, T key)二分查找

案例:

import java.util.HashSet;
import java.util.Set;

/**
 * @Classname TestSetCollection
 * @Description TODO:hashSet实现交集并集差集
 * @Date 2021/03/25 10:47
 * @Created by xx
 */
public class TestSetCollection {
    public static void main(String[] args) {
        Set<String> hs = new HashSet<String>();
        Set<String> hs2 = new HashSet<String>();


        hs.add("java");
        hs.add("c");
        hs.add("c++");
        hs.add("html");
        hs.add("css");

        hs2.add("css");
        hs2.add("html");
        hs2.add("js");
        hs2.add("layUi");

        //交集--->留下两个集合共有的值
        hs.retainAll(hs2);
        System.out.println(hs);
        //添加数据还原初始集合--->方便测试并集与差集
        hs.add("java");
        hs.add("c");
        hs.add("c++");

        //差集--->留下比较集合不含的值
        hs.removeAll(hs2);
        System.out.println(hs);
        //添加数据还原初始集合--->方便测试并集
        hs.add("html");
        hs.add("css");

        //并集--->合并两个集合
        hs.addAll(hs2);
        System.out.println(hs);

    }
}

8 复习回顾

map

map不属于Collection体系,为单独的集合体系.

标签:name,age,第十二章,System,println,Student,集合,JavaSE,out
来源: https://blog.csdn.net/YX_SYXS/article/details/115442399