java怎么创建一个set集合 java中创建集合

转载

mob64ca13f87273 2024-03-30 22:47:01

文章标签 java怎么创建一个set集合 java 列表数据结构类 文章分类 Java 后端开发

集合

使用集合的步骤
List集合

List接口中的成员方法
List集合实例

Set
Map
增强For循环
Collections工具类
迭代器
泛式

使用集合的步骤

创建集合对象
创建元素对象
将元素对象添加到集合对象中
遍历集合

List集合

List接口中的成员方法

public boolean add(E , e);
将数据添加到集合的末尾，这里的E是泛型的意思
public E get (int index);
根据索引，获取其对应的元素
public int size();
获取集合的长度

List集合实例

测试类：

package Demo1;

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

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        Student s1 = new Student(41,"乔峰");
        Student s2 = new Student(41,"乔峰");
        Student s3 = new Student(38,"虚竹");
        Student s4 = new Student(26,"段誉");
        //3.将元素对象添加到集合对象中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //获取索引为2的元素
        Object obj = list.get(2);
        System.out.println("索引为2的元素是：" + obj);
        //获取集合的元素个数
        System.out.println("集合的长度为：" + list.size());
        System.out.println("---------------------");
        //4.遍历集合
        for (int i = 0; i < list.size() ; i++) {
            Object obj2 = list.get(i);
            System.out.println("索引为" + i + "的元素是：" + obj2);
        }
    }
}

package Demo1;

public class Student {
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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

运行结果：

索引为2的元素是：Student{age=38, name='虚竹'}
集合的长度为：4
---------------------
索引为0的元素是：Student{age=41, name='乔峰'}
索引为1的元素是：Student{age=41, name='乔峰'}
索引为2的元素是：Student{age=38, name='虚竹'}
索引为3的元素是：Student{age=26, name='段誉'}

Set

特点：
不可重复，无序
Set集合保证元素的唯一性依赖：equals（）和hashCode（）两个方法
如果未在类中重置这两个方法，默认调用的是Object类中的这两个方法
而Object类中equals（）方法默认比较的是地址值是否相同
格式：Set<T> set = new HahSet<>();

测试类：

package Set;


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

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        Set<Student> set = new HashSet<>();
        //2.创建元素对象
        Student s1 = new Student("小一",11);
        Student s2 = new Student("小尔",12);
        Student s3 = new Student("小散",13);
        Student s4 = new Student("小思",14);
        Student s5 = new Student("小悟",15);

        //3.将集合对象添加到元素对象中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        //4.遍历集合
        System.out.println(set);
        System.out.println("-----------------------");

        System.out.println("通过迭代器实现");
        //通过迭代器遍历Set集合
        //A.通过集合对象获取其对应
        Iterator<Student> it = set.iterator();
        //B.判断迭代器中是否元素
        while(it.hasNext()){
            //C.如果有，就获取元素
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------");

        
        //通过增强for遍历Set集合
        System.out.println("通过增强for遍历Set集合:");
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

学生类：

package Set;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    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;
    }

    public Student() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

运行结果：

[Student{name='小思', age=14}, Student{name='小悟', age=15}, Student{name='小一', age=11}, Student{name='小尔', age=12}, Student{name='小散', age=13}]
-----------------------
通过迭代器实现
Student{name='小思', age=14}
Student{name='小悟', age=15}
Student{name='小一', age=11}
Student{name='小尔', age=12}
Student{name='小散', age=13}
-----------------------
通过增强for遍历Set集合:
Student{name='小思', age=14}
Student{name='小悟', age=15}
Student{name='小一', age=11}
Student{name='小尔', age=12}
Student{name='小散', age=13}

Map

特点：
双列集合，元素由键值对（Entry）构成：key - - value
key不可重复，value可以重复

应用：Map<T1,T2> map = new HahMap<>();

成员方法：

V put(K key,V value); 添加元素（键值对的形式，元素第一次添加，返回null，重复添加，会用新值覆盖旧值，并返回旧值
V get(Object key); 根据键获取其对应的值
Set<K> keySet(); 获取所有键的集合

遍历步骤：

获取所有键的集合 keySet（）
遍历所有的键，获取到每一个键 迭代器，增强for
根据键，获取指定的值 get（）

测试类：

package Map;

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

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        //键：学生的编号，值：具体的学生对象
        Map<Integer,Student> map = new HashMap<>();
        //2.创建元素对象
        Student s1 = new Student("小一",11);
        Student s2 = new Student("小尔",12);
        Student s3 = new Student("小散",13);
        //3.将元素对象添加到集合中
/*        Student stu1 = map.put(1,s1);
        System.out.println("stu1:" + stu1);
        Student stu2 = map.put(1,s2);
        System.out.println("stu2:" + stu2);*/
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);

        //根据键，获取值
        Student stu3 = map.get(2);
        System.out.println("key:" + 2 + ", value:" + stu3);

        //打印集合
        System.out.println(map);
        System.out.println("-----------------------");

        //4.遍历集合
/*        //迭代器实现
        //获取所有键的集合
        Set<Integer> keys = map.keySet();
        //遍历所有的键，获取带每一个键
        //获取迭代器对象
        Iterator<Integer> it = keys.iterator();
        while(it.hasNext()){
            //如果迭代器中有数据，就获取
            Integer key = it.next();
            //根据键,获取值
            Student value = map.get(key);
            System.out.println("key:" + key + "……value:" + value);
        }*/

        //通过增强for实现
        Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            //key就是双列集合中的每一个键
            Student value = map.get(key);
            System.out.println("key:" + key + "……value:" + value);
            
        }
        
    }
}

学生类：

package Map;

import java.util.Objects;

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 o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

运行结果：

key:2, value:Student{name='小尔', age=12}
{1=Student{name='小一', age=11}, 2=Student{name='小尔', age=12}, 3=Student{name='小散', age=13}}
-----------------------
key:1……value:Student{name='小一', age=11}
key:2……value:Student{name='小尔', age=12}
key:3……value:Student{name='小散', age=13}

增强For循环

格式：

for（元素的数据类型 变量名 : 要遍历的数组或者集合对象）{
	//循环体，变量也就是元素
}

快捷方式：iter-->回车

增强for的底层依赖的是迭代器（iterator）

测试类：

package 增强for循环;

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

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add(10);
        list.add(10);
        list.add(20);
        list.add(30);
        //4.遍历集合
        for (Object obj : list) {
            //obj是集合中的元素，其本身应该是Integer类型的数据
            Integer ii = (Integer)obj;
            System.out.println(ii);
        }
    }
}

Collections工具类

针对集合进行操作的工具类

sort（List <T>） 根据元素的自然顺序，将指定列表按升序排序
max（Collection<T>） 返回集合的最大元素
reverse（List <T>） 反转List集合元素
shuffle（List<T>） 使用默认的随机源置换指定的列表

实例：

package Collections工具类;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(1);
        list.add(3);
        list.add(5);
        list.add(2);
        list.add(4);
        list.add(6);

        System.out.println("没有操作集合前：" + list);
        System.out.println("--------------------------");

        //获取集合中的最大元素
        Integer max =  Collections.max(list);
        System.out.println("集合中的最大元素为：" + max);
        System.out.println("--------------------------");

    /*    //对集合进行升序排序
        Collections.sort(list);
        System.out.println("升序排序后的集合为：" + list);
        System.out.println("--------------------------");

        //对集合中的数据进行反转
        Collections.reverse(list);
        System.out.println("反转后的集合为：" + list);
        System.out.println("--------------------------");*/

        //对集合中的数据进行降序排序
        Collections.sort(list);
        Collections.reverse(list);
        System.out.println("对集合进行降序排序后：" + list);
        System.out.println("--------------------------");

        //随机置换，相当于洗牌
        Collections.shuffle(list);
        System.out.println("随机置换后的集合：" + list);
    }
}

运行结果：

没有操作集合前：[1, 3, 5, 2, 4, 6]
--------------------------
集合中的最大元素为：6
--------------------------
对集合进行降序排序后：[6, 5, 4, 3, 2, 1]
--------------------------
随机置换后的集合：[5, 6, 3, 4, 2, 1]

迭代器

对过程的重复，称为迭代。
迭代器是遍历collection集合的通用方式，可以在对集合遍历的同时进行添加，删除等操作。
列表迭代器是List体系独有的遍历方法，可以在集合遍历的同时进行添加，删除等操作，但是必须通过调用列表迭代器的方法来实现

常用方法：

next（）：返回迭代的下一个元素对象
hasNext（）：如果仍有元素可以迭代，则返回true

实例：

普通迭代器

package 迭代器;

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

public class Test {
   public static void main(String[] args) {
       //需求：通过迭代器遍历List集合
       //1.创建集合对象
       List list = new ArrayList();
       //2.创建元素对象
       //3.将元素对象添加到集合对象中
       list.add("a");
       list.add("b");
       list.add("c");
       //4.遍历集合
       //迭代器的用法
/*        //1、根据集合对象获取其对象的迭代器对象
       Iterator it = list.iterator();
       //2、判断迭代器中是否有元素
       while (it.hasNext()){//如果迭代器中有元素，就一直迭代
           //3、如果有就获取元素
           String s = (String)it.next();
           System.out.println(s);
       }*/
       System.out.println("-----------------------");
       //需求：判断集合中如果有字符串“b”，就在其后面添加一个字符串“java”
       //1、根据集合对象获取其对象的迭代器对象
       Iterator it = list.iterator();
       //2、判断迭代器中是否有元素
       while (it.hasNext()){//如果迭代器中有元素，就一直迭代
           //3、如果有就获取元素
           String s = (String)it.next();
           if ("b".equals(s)) { //这样写可以避免空指针异常
               //能走到这里，说明集合中有元素b
               list.add("java");//ConcurrentModificationException错误
           }
           System.out.println(s);
       }
   }

列表迭代器

package 迭代器;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test1 {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        //需求：判断集合中如果有字符串“b”，就在其后面添加一个字符串“java”
        //1、根据集合对象获取其对象的迭代器对象
        ListIterator lit = list.listIterator();;
        //2、判断迭代器中是否有元素
        while (lit.hasNext()) {
            //3、如果有就获取元素
            String s = (String)lit.next();
            if ("b".equals(s)) { //这样写可以避免空指针异常
                //能走到这里，说明集合中有元素b
                lit.add("java");
            }
            System.out.println(s);
        }
        System.out.println("-----------------");
        //打印新的集合中的值
        System.out.println(list);
    }
}

运行结果：

a
b
c
-----------------
[a, b, java, c]

总结：
普通的迭代器在遍历的过程中不能添加或删除元素，否则会报：并发修改异常；
列表迭代器在遍历的过程中可以修改集合中的元素（添加或删除等），但必须使用列表迭代器的方法

泛式

格式：List<数据类型> list = new ArrayList<数据类型>();实例：

package 泛型;

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

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        List list1 = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list1.add("a");
        list1.add("b");
        list1.add("c");
        //4.遍历集合
        for (Object obj : list1) {
            String s = (String)obj;
            System.out.println(s);
        }
        System.out.println("----------------");
        
        //演示泛式
        //1.创建集合对象
        List<String> list2 = new ArrayList<String>(); //在JDK5以后后面的String可省略
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list2.add("abc");
        list2.add("bcd");
        list2.add("cde");
        //4.遍历集合
        for (Object obj : list2) {
            System.out.println(obj);
        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。