JavaSE_第十二章:集合

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量167 收藏
点赞数
分类专栏： # JavaSE学习历程 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YX_SYXS/article/details/115442399
版权

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体系,为单独的集合体系.

开心点!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaSE_第12章 集合
yanyu1994的博客
07-26 340
第12章 集合 主要内容 List集合 Set集合 Map集合 学习目标 能够熟练使用Collection集合的API 能够使用Iterator迭代器遍历Collection系列的集合 能够使用foreach遍历Collection系列的集合 能够说出List集合和Set集合的区别 能够说出List集合各种实现类的区别 能够说出Set集合各种实现类的区别 能够说出Collection集合与Map集合的区别 掌握Map集合的常用API 能够遍历Map集合 能够说出Map集合各种实现类
JavaSE第17篇：集合之Map集合
【01编程】的博客
08-23 278
JavaSE第17篇：集合之Map集合 核心概述：本篇我们将会学习JavaSE中的Map集合、可变参数，并且我们会继续完善综合案例之斗地主洗牌发牌功能。同时我们也会体验一下集合的嵌套使用。 第一章：Map集合 1.1-概述（了解） 现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。 我们通过查看Map接口描述，发现Map接口下的集合与Co
JavaSE_第十三章:异常
开心点的博客
04-05 185
JavaSE学习历程 第一章:Java初识 第二章:Java语言基础 第三章:选择结构与分支结构 第四章:循环结构 第五章:方法/函数 第六章:数组 第七章:面向对象 第八章:三大特性 第九章:三个修饰符 第十章:接口 第十一章:常用类 第十二章:集合 第十三章:异常 1 异常 1.1 异常 概念:程序在运行过程中出现的特殊情况. 1.2 异常的必要性 任何程序都可能存在大量的未知问题、错误. 如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失. 2 异常分类 Throwable
JavaSE学习：第二十六章：集合作业
HSF_213156的博客
04-02 215
1、作业一： package hsf.com.HomeWork_;/* * @author HSF * @version 8.0 */ import java.util.ArrayList; /* * 按要求实现： (1)封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对像 时只打印标题； (②)只提供一个带参数的构造器，实例化对像时，只初始化标题；并且实例化两个对象： 新闻一：新冠确诊病例超干万，数百万印度教信徒赴恒河“圣浴”引民众担忧 新闻二：男子突然
javase学习第二十天：集合简介
qq_44724899的博客
09-29 194
学习
2023最新版JavaSE教程——第12天：集合框架
Amo Xiang的博客
12-22 1310
本章讲解 Java 中的集合，学习 List、Set、Map 三种集合的应用。
JavaSE：第十七章：编程测试题
Java程序员廖志伟
01-10 942
**练习：求1+2!+3!+...+20!的和**     long sum = 0;     for (int i = 1; i &lt;= 20; i++) {         long temp= 1;         for (int j = 1; j &lt;= i; j++) {             temp *= j;         }         sum += temp...
JavaSE：第十六章：java8新特性
Java程序员廖志伟
10-19 1173
作者：java_wxid ##java8内容 1.Lambda表达式 ★ 2.函数式接口 ★ 3.方法引用 ★ 4.构造器引用|数组引用 ★ 5.StreamAPI ★ 6.接口中可以定义默认方法和静态方法 ★ 7.Optional类的引入：为了减少空指针异常【了解】 8.新日期API【了解】 9.重复注解【了解】 10.Nashone引擎的使用：在jvm上运行js【后面课程】 ##Jav...
JavaSE学习笔记_12：Java集合框架
java_cm66的博客
03-02 561
Java集合框架   集合框架：     集合框架中有许多类和接口，它们都是容器，就像数组一样，可以存取很多数据。但是比数组灵活，它存储的数据类型任意（泛型。可以指定）（比如可以字符串，存类对象。其实字符串也是类对象，只不过是java已经定义好多类。如果要存自定义类的对象，必须要要将这个类先描述出来。且用不同的容器存储需要复写父类中的一些方法，好让集合中的方法或者其他方法在底层调用它们。
JavaSE学习笔记(五)：集合
weixin_46476301的博客
04-17 1063
前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matp...
尚硅谷_JavaSE_第12章_集合与泛型_扩展练习_附带参考答案.md
02-22
尚硅谷_JavaSE_第12章_集合与泛型_扩展练习_附带参考答案.md
Thinking_in_Java_4th_edition.pdf_java_in_javase_
10-01
12. **Java SE**："Java in JavaSE"标签表明这本书主要关注的是Java标准版（Java SE），涵盖了Java桌面应用开发所需的所有核心知识。 《Thinking in Java》不仅适合初学者，也对有经验的开发者有着很高的参考价值，...
JavaSe基础部分第六章代码
09-23
本章节我们将深入探讨JavaSE的基础部分，特别是第六章涉及的编程概念和技术。在这个压缩包中，"chapter06"可能包含了源代码示例，帮助学习者理解并实践这些概念。 1. **类与对象**：Java是一种面向对象的语言，第六...
张龙老师JAVASE第12.13源码.rar
04-07
"Lesson.12_code"表示这部分内容专注于讲解和实践Java SE的第12章内容，可能涵盖类、对象、继承、多态等面向对象编程的基本概念，或者是异常处理、集合框架、IO流等高级特性。 2. "[北京圣思园Java培训教学视频]Java...
JavaSE第一阶段笔试题.docx
08-18
12. **选择题第十二题**：字符串与整数相加会进行字符串连接，因此输出结果是`52`。 13. **选择题第十三题**：考察构造函数的调用顺序。创建`Child`对象时，会先调用`Child`的构造函数，然后通过`this`调用`People`...
配置Java开发环境
Broken_x的博客
07-10 1461
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 352
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 427
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2326
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
Artifact javase_demo4:war exploded: Error during artifact deployment. See server log for details.如何解决
06-09
解决这个问题需要您进一步查看服务器日志，以了解错误的详细信息，从而更好地确定问题所在。以下是一些可能导致此错误的常见原因和相应的解决方法： 1. 项目依赖项缺失或版本不兼容：您可以尝试更新依赖项或在 pom....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值