Java编程 Javase10_set接口和list接口一样,同样继承自什么接口-优快云博客

本文详细介绍了Java中的List接口及其主要实现类ArrayList、LinkedList和Vector的特点与常用方法。List接口是一个有序集合，允许元素重复，支持索引操作。ArrayList基于数组实现，查询快但增删慢；LinkedList采用链表结构，增删快但查询慢；Vector是线程安全的列表，性能较低。此外，还展示了Set接口的HashSet和LinkedHashSet，前者保证元素唯一性，后者同时保证唯一性和插入顺序。最后，讨论了可变参数和Collections类的常用方法，如排序和打乱集合顺序。

一、List集合

（一）List接口介绍

java.util.list接口继承自collection接口，时单列集合中的一个重要分支，习惯性的会将实现了List接口的对象称为List集合。
特点：

它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33.那么集合中，元素的存储就是按照11、22、33的顺序完成的。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

（二）List接口中带索引的方法（特有）

public void add(int index,E element):将指定元素添加到集合中的指定位置。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素。
public E set（int index,E element):用指定元素替换集合中指定位置的元素，返回值的更新前的元素。

注意：操作索引时一定要防止索引越界异常。

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

public class list1 {
    public static void main(String[] args) {
        //使用多态的方法创建一个list集合
        List<String> list =new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        System.out.println(list);
        //使用list的add方法，指定索引值和元素
        list.add(3,"love");
        System.out.println(list);
        //使用list的remove方法，指定索引值
        String s=list.remove(2);//remove方法返回值为移除元素
        System.out.println("被移除的元素"+s);
        System.out.println(list);
        //使用list的set方法，指定索引值和新元素，返回值为之前元素
        String m=list.set(2,"shit");
        System.out.println("被替换的元素"+m);
        System.out.println(list);
        System.out.println("-------------------------------------------");
        //list集合遍历的三种方法
        //普通for循环，使用list中的get方法
        for (int i = 0; i < list.size(); i++) {
            String n =list.get(i);
            System.out.println(n);
        }
        System.out.println("-------------------------------------------");
        //使用迭代器遍历
        Iterator it =list.iterator();
        while(it.hasNext()){
            String t = (String) it.next();
            System.out.println(t);
        }
        System.out.println("-------------------------------------------");
        //使用增强for遍历
        for (String f:
             list) {
            System.out.println(f);
        }
    }
}

[a, b, c, d, a]
[a, b, c, love, d, a]
被移除的元素c
[a, b, love, d, a]
被替换的元素love
[a, b, shit, d, a]
-------------------------------------------
a
b
shit
d
a
-------------------------------------------
a
b
shit
d
a
-------------------------------------------
a
b
shit
d
a

二、List的集合子类

（一）ArrayList集合

java.util.Arraylist集合数据存储的结构是数组结构。元素增删慢，查找快。

（二）LInkedList集合

1、特点

底层是一个链表结构，查询慢但增删快
里面包含了大量操作首尾元素的方法
注意：使用LinkedList集合特有的方法，不能使用多态

2、常用方法

public void addFirst(E e):将指定元素插入此列表的开头
public void addLast(E e):将指定元素添加到此列表的结尾
public void push(E e):将元素推入此列表所表示的堆栈

public E getFirst():返回此列表的第一个元素
public E getLast():返回此列表的最后一个元素

public E pop():从此列表所表示的堆栈处弹出一个元素
public E removeFirst()；移除并返回此列表的第一个元素
public E removeLast():移除并返回此列表的最后一个元素

public boolean isEmpty():如果此列表不包含元素，则返回true

import java.util.LinkedList;

public class linkedlist {
    public static void main(String[] args) {
        show1();
        show2();
        show3();

    }

    private static void show3() {
        //删除元素的三种方法
        LinkedList<String> list3 = new LinkedList<>();
        list3.add("dog");
        list3.add("cat");
        list3.add("snake");
        //利用isEmpty的取反判断集合是否为空
        if(!list3.isEmpty()) {
            String a = list3.removeFirst();
            System.out.println("被移除的第一个元素为：" + a);
            String b = list3.removeLast();
            System.out.println("被移除的最后一个元素为：" + b);
            String c = list3.pop();
            System.out.println("被移除的元素为：" + c);
        }
    }

    private static void show2() {
        //获取首尾元素的方法
        LinkedList<Integer> list2 = new LinkedList<>();
        list2.add(857);
        list2.add(965);
        int a= list2.getFirst();
        System.out.println(a);
        int b = list2.getLast();
        System.out.println(b);
    }

    private static void show1() {
        //插入元素的三种方法
        LinkedList<String> list1 = new LinkedList<>();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        System.out.println(list1);
        list1.addFirst("love" );
        list1.addLast("shit");//addLast等效于add方法
        list1.push("like");//push等效于addFirst方法
        System.out.println(list1);
    }
}

[a, b, c]
[like, love, a, b, c, shit]
857
965
被移除的第一个元素为：dog
被移除的最后一个元素为：snake
被移除的元素为：cat

（三）Vector集合

Vector类可以实现可增长的对象数组，为单线程，运行速度较慢。

二、Set接口

java.util.Set接口和List接口一样，同样继承自Collection接口，接口中的方法与Collection接口中的方法基本一致。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Set集合中取出元素的方式可以采用：迭代器、增强for。因为没有索引方法所以不能使用普通for遍历。

HashSet集合

实现了Set接口

1、特点

不允许存储重复的元素
没有索引，没有索引方法，不能使用for循环遍历
是一个无序的集合，存储元素和取出元素的顺序的顺序有可能不一致
底层是一个哈希表结构（查询速度非常快）

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

public class hash {
    public static void main(String[] args) {
        Set<Integer> list = new HashSet<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);//不允许出现重复元素会被删除
        System.out.println(list);
        //使用迭代器循环
        Iterator it = list.iterator();
        while (it.hasNext()){
            int num = (int) it.next();
            System.out.println(num);
        }
        System.out.println("---------------------------------------");
        //使用增强for
        for (Integer num : list) {
            System.out.println(num);
        }

    }
}

[1, 2, 3]
1
2
3
---------------------------------------
1
2
3

2、哈希值

是一个十进制的证书，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址值，不是数据实际存储的物理地址）
哈希值的获取方法

int hashCode() 返回该对象的哈希码值

String类重写类hashCode方法，使返回的哈希值一致

public static void main(String[] args) {
        P p1 =new P();
        P p2 = new P();
        int h1=p1.hashCode();
        int h2=p2.hashCode();
        System.out.println(h1+" "+h2);
        String s1 =new String("abc");
        String s2 =new String("abc");
        System.out.println(s1.hashCode()+" "+s2.hashCode());
     
    }

2129789493 668386784
96354 96354

3、哈希表结构

4、Set集合存储元素不重复的原理

4、HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证集合中的对象唯一。

import java.util.Objects;

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

    public student() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof student)) return false;
        student student = (student) o;
        return getAge() == student.getAge() &&
                Objects.equals(getName(), student.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge());
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + 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;
    }
}

import java.util.HashSet;

public class person {
    public static void main(String[] args) {
        student s1= new student("zhangsan",18);
        student s2=new student("zhangsan",18);
        student s3 =new student("lisi",20);
        HashSet<student> stulist = new HashSet<>();
        stulist.add(s1);
        stulist.add(s2);
        stulist.add(s3);
        System.out.println(stulist);//重写hashCode与equals方法后，重复元素不能存储

    }
}

[student{name='lisi', age=20}, student{name='zhangsan', age=18}]

5、LinkedHashSet集合

是HashSet下的一个子类，是链表和哈希表组合的一个数据存储结构。保证元素的唯一性和有序性。（有序指以什么顺序输入就以什么顺序输出）

 public static void main(String[] args) {
        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("ooo");
        linked.add("abc");
        System.out.println(linked);
    }
//输出为：[www, ooo, abc]。

三、可变参数

1、使用前提：当方法的参数列表数据类型已经确定，但是参数的个数不确定时可以使用可变参数

2、使用格式：定义方法时使用

修饰符 返回值类型 方法名（数据类型...变量名）{}

3、可变参数的原理：

可变参数底层是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数。传递的参数个数，可以是0个（不传递），1，2...多个
注意：一个方法的参数列表，只能有一个可变参数。如果方法的参数有多个，那么可变参数必须写在参数列表的末尾。

 public static void main(String[] args) {
       int a= add(100,200,300,400,865656);
        System.out.println(a);
    }

    private static int add(int...arr) {
        int sum=0;
        for (int i : arr) {
            sum+=i;
        }
        return sum;
    }

可变参数的特殊写法（终极）

public static void method(Object...obj){
}

四、Collections

常用方法

public static <T> boolean addAll(Collecton<t> c,T...elements):往集合中添加一些元素。
public static void shuffle（List<?> list):打乱集合顺序

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

public class c1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c");
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

[a, b, c]
[a, c, b]

public static<T> void sort(List<T> list):将集合中的元素按照默认规则排序

注意：被排序的集合里边存储的元素必须实现Comparble，重写接口中的方法compareTo定义排序的规则。

Comparble接口的排序规则：

this-参数：升序
参数-this ：降序

public class people implements Comparable<people> {
    private String name;
    private int age;

    public people() {
    }

    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 people(String name, int age) {
        this.name = name;
        this.age = age;
    }


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

    @Override
    public int compareTo(people o) {
        return this.age-o.age;//升序
        //return 0.age-this.age:降序
    }


}

public class c2 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"a","c","b","d","e");
        Collections.sort(list1);
        System.out.println(list1);
        ArrayList<Integer> list2= new ArrayList<>();
        Collections.addAll(list2,1,3,4,0,8);
        Collections.sort(list2);
        System.out.println(list2);
        ArrayList<people>list3 = new ArrayList<>();
        list3.add(new people("zhangsan",18));
        list3.add(new people("lisi",25));
        list3.add(new people("wangmazi",20));
        Collections.sort(list3);
        System.out.println(list3);

    }
}

[a, b, c, d, e]
[0, 1, 3, 4, 8]
[people{name='zhangsan', age=18}, people{name='wangmazi', age=20}, people{name='lisi', age=25}]

public static <T> void sort(List<T>,Comparator<? super T>):将集合中元素按照指定规则排序。
Comparator和Comparable区别：
    Comparable：自己（this） 和别人（参数) 比较，自己需要实现接口，重写比较的规则
    Comparator：相当于找个第三方进行比较
    排序规则：o1-o2:升序
              o2-o1:降序

public class stu  {
    private String name;
    private int 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 stu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public stu() {
    }

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class c3 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(0);
        list1.add(235);
        list1.add(5);
        Collections.sort(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(list1);
        ArrayList<stu> list2 =new ArrayList<>();
        list2.add(new stu("zhangsan",18));
        list2.add(new stu("lisi",89));
        list2.add(new stu("wangwu",22));
        list2.add(new stu("wuqi",18));
        Collections.sort(list2, new Comparator<stu>() {
            @Override
            public int compare(stu o1, stu o2) {
                int result = o1.getAge()- o2.getAge();
                if(result==0){
                    result= o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list2);
    }
}

[0, 5, 235]
[stu{name='wuqi', age=18}, stu{name='zhangsan', age=18}, stu{name='wangwu', age=22}, stu{name='lisi', age=89}]