JavaSE 12:集合

集合

ArrayList

List继承了Collection接口,有三个实现的类

ArrayList

​ 数组列表，数据采用数组方式存储。 类似于动态数组适合查找元素

LinkedList

​ 链表，具有链表性质 适合删除元素

Vector

​ 数组列表，添加同步锁,线程安全的

package Day2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class Demo {
        public static void main(String[] args) {
            Collection<Object> c0 = new ArrayList<>();
            c0.add("a");
            c0.add("b");
            c0.add("c");
            c0.add("d");
            Collection<Object> c1 = new ArrayList();
            c1.add("a");
            c1.add("b");
            c1.add("c");
            System.out.println(c0.retainAll(c1));//交集 集合元素不一致变为true
            System.out.println(c0);
            Collection c3 = new ArrayList();
            c3.add(8);
            c3.add(5);
            c3.add(6);
            Object obj[] = c3.toArray();
            System.out.println(Arrays.toString(obj));
            test(1, 2, 3, 4, 5, 6);
            tr(8,10,8,9,8,5);
            Integer []a={1,2,3,4,5,6};
            List<Integer> list= Arrays.asList(a);

        }
        public static void test(int...a){
                System.out.println(a);
            }
    public static void tr(int b,int...a){
        System.out.println(a);
    }
    }

集合的遍历和删除

import java.util.ArrayList;
import java.util.*;
public class Day3 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add("a");
        list.add("d");
        list.add("b");
        list.add("d");
        list.add("c");
        list.add("d");
        //迭代器的遍历
        list.forEach(e-> System.out.print(e+" "));//jdk8以后的forEach语句
        System.out.println();
        Iterator it=list.iterator();
        it.forEachRemaining(e-> System.out.print(e+" "));//jdk8以后的forEach语句
        System.out.println();
        while(it.hasNext()){
            Object obj=it.next();
            System.out.print(obj+" ");
        }
        System.out.println();

      for(Object obj:list){
          //不建议删除元素
          System.out.print(obj+" ");
      }
        System.out.println();
        for(Object obj:list){
            //不建议删除元素
            if(obj.equals("a")) {
                list.remove(obj);
                break;//只能删除一个元素不能删除全部的元素所以建议使用迭代器的方法删除
            }
        }
        System.out.println(list);
    Iterator itt=list.iterator();
    while(itt.hasNext()){
        Object obj=itt.next();
        if(obj.equals("d"))
       itt.remove();//使用该方法删除
    }
        System.out.println(list);
    }
}

泛型

package Dya3;
//泛型：泛指一种类型，类型不确定，可以以参数的形式传递。
//类型必须是引用类型
//数组可以存储基本数据类型，引用数据类型如String
//集合只能存储引用数据类型，list.add(8)存在自动装箱。
public class Demo <T>{
    public T test(T t){
        return null;
    }
    public static void main(String[] args) {
        Demo<Integer> demo=new Demo<>();
        demo.test(8);
    }
}

HashSet

Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的。

HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。

底层数据结构是哈希表+链表。

哈希表依赖于哈希值存储。

package Dya3;

import java.util.Objects;

public class Student {
    private String name;
    private String id;

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

//重写hashCode()和equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name) &&
                Objects.equals(id, student.id);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

package Dya3;
import java.util.HashSet;
public class hashDemo {
    public static void main(String[] args) {
        HashSet<Student> set = new HashSet<>();
        Student s1 = new Student("100", "jim0");
        Student s2 = new Student("100", "jim0");
        Student s3 = new Student("102", "jim2");
        Student s4 = new Student("103", "jim3");
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        System.out.println(set);
        HashSet st = new HashSet<>();
        st.add(123);
        st.add(123);
        st.add("jjk");
        st.add("jjk");
        System.out.println(st);
       //遍历
        set.forEach(e-> System.out.println(e));
        Iterator it= set.iterator();
        it.forEachRemaining(e->System.out.println(e));
    }
}

TreeSet<Integer> set=new TreeSet<>();
set.add(8);
set.add(7);
set.add(9);
set.add(8);
System.out.println(set);
TreeSet<String> str=new TreeSet<>();
str.add("abc");
str.add("def");
str.add("abc");
str.add("ghi");
System.out.println(str);

package Dya3;
import java.util.Objects;
public class Student implements  Comparable<Student>{
    private int id;
    private String name;
    public Student(int id,String name) {
        this.name = name;
        this.id=id;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
    @Override
    public int compareTo(Student o) {
        return this.id-o.id;
    }
}

package Dya3;

import sun.reflect.generics.tree.Tree;

import java.util.TreeSet;

public class TreesetDemo {
    public static void main(String[] args) {
        TreeSet<Student> st=new TreeSet<>();
        Student s1=new Student(101,"gll");
        Student s2=new Student(102,"lyh");
        Student s3=new Student(101,"gll");
        Student s4=new Student(103,"xjx");
        st.add(s1);
        st.add(s2);
        st.add(s3);
        st.add(s4);
        System.out.println(st);
    }
}