java学习笔记——集合和泛型

Java集合框架

一个用来代表和操纵集合的统一架构。

Java 集合框架主要包括两种类型的容器：

• 集合（Collection），存储一个元素集合

• 图（Map），存储键/值对映射

Collection 接口又有子类型：

• List
• Set
• Queue
• ……

再下面是一些抽象类，

最后是具体实现类，常用的有：

ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、>LinkedHashMap ……

所有的集合框架都包含如下内容：

• 接口：代表集合的_抽象数据类型_。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象

• 实现（类）：集合接口的具体实现。从本质上讲，它们是_可重复使用的数据结构_，例如：>ArrayList、LinkedList、HashSet、HashMap

• 算法：实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为_多态_，那是因为相同的方法可以在相似的接口上有着不同的实现

Map 里存储的是键/值对。

Java集合框架位于java.util包中， 当使用集合框架的时候需要进行导包。

集合接口

1. Collection接口

   最基本的集合接口，一个Collection代表一组Object（即Collection元素），Java不提供直接继承Collection的类，只提供继承于的子接口（如List和set）

   存储一组不唯一（允许有相同的元素）、无序的对象。

2. List接口

   List接口是一个有序的 Collection，能够精确的控制每个元素插入的位置，能够通过索引来访问List中的元素（第一个元素的索引为 0）

   存储一组不唯一、有序的对象。

3. Set

   存储一组唯一（不保存重复对象），无序（没有下标）的对象。

4. Map

   存储一组键值对象，提供key（键）到value（值）的映射。

   • Map集合key的特点：无序不可重复

   • key和value都存储对象内存地址（引用？）

集合类

汇总表格

List

• ArrayList
• LinkedList
• Vector
  
  

Collection

没有使用“泛型”之前，Collection中可以存储Object的所有子类型。使用了“泛型”之后，Collection 中只能存储某个具体的类型。

集合中不能存储基本数据类型，也不能存储对象，只能存储对象的引用。

常用方法

import java.util.ArrayList;
import java.util.Collection;

public class test02 {
    public static void main(String[] args) {
        //多态
        Collection c=new ArrayList();//创建一个对象,接口是抽象的，无法实例化        
        //测试Collection接口中的常用方法
        c.add(1200);//自动装箱，实际上是放进去了一个对象的内存地址Integer x=new Integer(1200);
        c.add(new Object());
        c.add(new Student());
        c.add(true);//自动装箱
		System.out.println(c.size());//获取集合中元素个数，并打印
        //判断集合中是否包含1200
        System.out.println(c.contains(1200));//true
        System.out.println(flag);
        c.remove(1200);//删除集合中元素
        c.clear();//清空集合
        //判断集合是否为空
        System.out.println(c.isEmpty());
        //转换成数组
		Object[] objs=c.toArray();
        for(int i=0;i<objs.length;i++) {
            Object o=objs[i];
            System.out.println(o);
        }
    }
}

class Student{

}

List

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

public class test02 {
    public static void main(String[] args) {
        List l =new ArrayList();
        l.add("A");
        l.add("B");
        l.add("C");
        l.add(1,"D");//在列表指定位置插入指定元素
        Object first=l.get(0);//根据下标获取元素
        System.out.println(l.indexOf("B"));//获取指定对象第一次出现处的索引
        System.out.println(l.lastIndexOf("B"));//获取指定对象最后一次出现处的索引
        l.remove(0);//删除指定下标位置的元素
        l.set(2,"E");//修改指定位置元素
    }
}

ArrayList

1. 默认初始化容量是10（先创建了一个长度为0的数组，当添加第一个元素时，初始化容量10）

2. 底层是Object类型的数组

3. 可以指定初始化容量

   //构造方法
   	ArrayList l1 =new ArrayList();
   	ArrayList l2 =new ArrayList(20);
   

4. ArrayList集合扩容

   增长到原容量的1.5倍

TreeSet

import java.util.Iterator;
import java.util.TreeSet;

/*定义一个账户类(Account)，它包含private成员变量name，id，age，balance(余额），每个属性都要写get，set方法，并重写 toString 方法输出 name, id,age,balance
要求：
创建Account类的 5 个对象，并把这些对象放入 TreeSet 集合中
分别按以下两种方式对集合中的元素进行排序，并遍历输出：
	①按balance的大小倒序输出
	②按姓名name按字典顺序（a、b、c…）排列输出*/
public class test02 {
    public static void main(String[] args) {
        Account a1=new Account("n1","id1",19,1200);
        Account a2=new Account("n2","id2",18,1395);
        Account a3=new Account("n3","id3",20,1871);
        Account a4=new Account("n4","id4",29,12020);
        Account a5=new Account("n5","id5",25,5223);
        TreeSet<Account> treeSet=new TreeSet<>();
        treeSet.add(a1);
        treeSet.add(a2);
        treeSet.add(a3);
        treeSet.add(a4);
        treeSet.add(a5);

        Iterator<Account> it=treeSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
class Account implements Comparable<Account>{
    Account(){}
    Account(String name,String id,int age,int balance){
        this.name=name;
        this.id=id;
        this.age=age;
        this.balance=balance;
    }
    private String name;
    private String id;
    private int age;
    private int balance;
	//省略get，set方法
    @Override
    public String toString() {
        return "name:"+this.name+"\tid:"+this.id+"\tage:"+this.age+"\tbalance:"+this.balance;
    }

    @Override
    public int compareTo(Account o) {
        if(this.balance==o.balance){
            return this.name.compareTo(o.name);
        }else {
            return o.balance-this.balance;
        }

    }
}

迭代器（Java Iterator）

迭代器是一个对象，它的工作是遍历并选择序列中的对象，它提供了一种访问一个容器(container)对象中的各个元素，而又不必暴露该对象内部细节的方法。

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代ArrayList和 HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。

调用方法iterator()可以返回一个迭代器，用于迭代（遍历）集合。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class test02 {
    public static void main(String[] args) {
        Collection c=new ArrayList();
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new  Object());
        Iterator it =c.iterator();//迭代器对象it负责遍历/迭代集合中的元素
        while (it.hasNext()){//方法返回true表示还有元素可以迭代，反之没有；迭代器最初并没有指向第一个元素
            Object obj=it.next();//该方法让迭代器前进一位，并返回指向的元素
            System.out.println(obj);
        }

    }
}

集合结构发生改变，迭代器必须重新获取。

Collections

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

public class test02 {
    public static void main(String[] args) {
        ArrayList<String> l =new ArrayList<>();
        l.add("abd");
        l.add("abc");
        l.add("abe");
        Collections.synchronizedList(l);//线程安全的
        Collections.sort(l);//保证其中元素实现了Comparable接口
        Iterator it =l.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

---

参考
[1] https://www.bilibili.com/video/BV1Rx411876f?p=663
[2]https://www.runoob.com/java/java-collections.html