java利用list对象的get方法得到ts对象 java list get set

一.List集合

1. List接口
   java.util.list接口继承自Collection接口，是一种单列集合。
   List集合主要特点是：允许出现重复的元素，元素是有序的，存入和取出的顺序是一样的，是以一种线性方式进行存储的，能够用索引来访问集合中的元素。
2. 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)：用指定元素替换此列表中指定位置的元素

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

        list.add(1);
        list.add(3);
        list.add(2);
        // 在指定位置添加add
        list.add(2,4);
        System.out.println(list);   // 输出：[1, 3, 4, 2]

        // 删除remove
        list.remove(2);
        System.out.println(list);   // 输出：[1, 3, 2]

        // 修改set
        list.set(0,11);
        list.set(2,22);
        System.out.println(list);   // 输出：[11, 3, 22]

        // 获取List数据 get
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");    // 输出：11 3 22 
        }
    }
}

1. List的子类

• ArrayList集合
  ArrayList集合存储的结构是数组结构，元素增删慢，查找快，主要多用于查询数据和遍历数据。
• LinkedList集合
  LinkedList集合存储的结构是链表结构，元素添加，删除快。
  LinkedList是一个双向链表，既继承了List的方法，LinkedList提供许多首尾操作的方法，主要有以下一些：

• public void addFirst(E e)：在此列表的开始处插入指定的元素。
• public void addLast(E e)：将指定的元素插入列表的尾部。
• public E getFirst()：返回此列表中的第一个元素。
• public E getLast()：返回此列表中的最后一个元素。
• public E removeFirst()：移除并返回此列表中第一个元素。
• public E removeLast()：移除并返回此列表的最后一个元素。
• public E pop()：从这个列表所表示的堆栈中弹出一个元素。
• public void push(E e)：将一个元素压栈到该列表所表示的堆栈上。

public class ListDemo2 {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        // 添加元素
        linkedList.addFirst("张三");
        linkedList.addFirst("李四");
        linkedList.addFirst("王五");
        System.out.println(linkedList); // 输出：[王五, 李四, 张三]
        // 获取元素
        System.out.println(linkedList.getFirst()); // 输出：王五
        System.out.println(linkedList.getLast());  // 输出：张三
        // 删除元素
        System.out.println(linkedList.removeLast()); // 输出：张三
        System.out.println(linkedList); // 输出：[王五, 李四]

        System.out.println(linkedList.removeFirst());   // 输出：王五
        System.out.println(linkedList); // 输出：[李四]

        // 压栈
        linkedList.push("赵六");
        System.out.println(linkedList); // 输出：[赵六, 李四]

        // 出栈
        System.out.println(linkedList.pop()); // 输出：赵六
    }
}

二.Set集合

1. Set接口
   java.util.Set接口继承自Collection接口，方法Collection中的基本一致，没有做功能的扩充，只是对于Collection接口来说，Set接口更加严格。
   Set接口的特点：元素无序，没有索引。
   因为Set集合是无序的并且没有索引，所以取出Set集合的元素可以采用迭代器或者增强for。
   Set集合子类有多个，这里主要介绍两个：java.util.HashSet和java.util.LinkedHashSet.
2. Set集合子类

• HashSet
  HashSet是根据对象的哈希值来确定元素在集合中的存储位置的，因此具有比较良好的存储和查找性能。
  HashSet保证元素的唯一性主要依赖于：hashCode和equals方法。
  如果集合存储的是自定义对象，要保证元素唯一，就必须重写hashCode和equals方法。
  示例：HashSet存储基本元素

public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();

        hs.add("张三");
        hs.add("李四");
        hs.add("王五");
        System.out.println(hs); // 输出：[李四, 张三, 王五]

        // 遍历元素
        for (String s : hs) {
            System.out.print(s + " ");
        } // 输出： 李四 张三 王五
    }
}

示例：HashSet存储自定义对象

1.先创建自定义对象（保证元素唯一，需要重写hashCode方法和equals方法）

import java.util.Objects;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

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

    public void setId(int id) {
        this.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(name, id);
    }
    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

2.Set集合存储

public class SetDemo1 {
    public static void main(String[] args) {
        // 1. 创建集合
        HashSet<Student> hs = new HashSet<>();
        // 2. 创建Student对象
        Student st1 = new Student("张三", 1);
        Student st2 = new Student("李四", 2);
        Student st3 = new Student("王五",3);
        Student st4 = new Student("张三",1);
        Student st5 = new Student("李四", 5);
        // 3. 集合添加元素
        hs.add(st1);
        hs.add(st2);
        hs.add(st3);
        hs.add(st4);
        hs.add(st5);
        // 4. 打印输出
        for (Student s: hs) {
            System.out.println(s);
        }
        // 输出：
        /*
        Student{name='王五', id=3}
        Student{name='张三', id=1}
        Student{name='李四', id=5}
        Student{name='李四', id=2}
        */
    }
}

• LinkedHashSet
  上面介绍到Set集合是存进去元素是没有顺序的，如果要保证有序，则需要使用LinkedHashSet，它是链表和哈希表组合的一个数据结构。

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        LinkedHashSet<String> hs = new LinkedHashSet<>();

        hs.add("张三");
        hs.add("李四");
        hs.add("王五");
        System.out.println(hs); // 输出：[张三, 李四, 王五]

        // 遍历元素
        for (String s : hs) {
            System.out.print(s + " ");
        } // 输出： 张三 李四 王五
    }
}