海阔天空

手机扫码查看

集合框架之List集合

什么是集合
概念：对象的容器，存储对象的对象，可代替数组
特点：容器的工具类，定义了对多个对象进行操作的常用方法
位置：java.util.*;

collection体系集合
interface collection该体系结构的根接口，代表一组对象，称为集合
|-interface List：List接口的特点：有序有下标，元素可重复
|–class ArrayList、Class LinkedList、Class Vector
|-interface Set：Set接口的特点：无序无下标元素不可重复
|–Class HashSet、Class SortedSet、Class TreeSet

Collection父接口
特点：代表一组任意类型的对象，无序无下标
方法：
boolean add(Obect obj)//添加一个对象
boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中
void clear();//清空此集合中的所有对象
boolean contains(Object obj);//检查此集合是否包含obj对象
boolean equals(Object obj);//比较此集合是否与指定对象相等
boolean isEmpty();//判断此集合是否为空
boolean remove(Object obj);//在此集合移除obj对象
int size();//返回此集合中的元素个数
Object[] toArray();//将此集合转换成数组

List集合

List子接口
特点：有序有下标元素可重复
方法：
void add(int index,Object o);//在index位置插入对象0
boolean addAll(int index,Collection c);//将一个集合中的元素添加到此集合中的index位置
Object get(int index);//返回集合中指定位置的元素
List subList(int fromIndex,int toIndex);//返回fromIndex和toIndex之间的集合元素

public static void main(String[] args) {
    ArrayList list=new ArrayList();
    list.add(8);
    list.add(158.8);
    list.add("hello");
    list.add(true);
    list.add('A');
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }
}

List实现类

ArrayList:
数组结构实现，查询快，增删慢
JDK1.2版本，运行效率快，线程不安全

Vector：
数组结构实现，查询快，增删慢
JDK1.0版本，运行效率慢，线程安全

LinkedList:
链表结构实现，增删快，查询慢

不同结构实现方式

ArrayList:必须开辟连续空间，查询快，增删慢
LinkedList:无序开辟连续空间，查询慢，增删快

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
特点：
编译时即可检查，而非运行时抛异常
访问时，不必类型转换(拆箱)

public static void main(String[] args) {
    List<Integer> list=new ArrayList<Integer>();
    list.add(8);
    list.add(12);
    list.add(99);
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }
}

实例泛型和静态泛型

import java.util.*;

public class demos{
    public static void main(String[] args) {
        //实例泛型
        MyClass<Integer> mc1=new MyClass<Integer>();
        mc1.m1(22);
        MyClass<Double> mc2=new MyClass<Double>();
        mc2.m1(88.8);
        MyInterface<String> mi=new MyImpClass();
        mi.m2("hello");
        //静态泛型
        MyStaticClass.method("hello"); //ERROR 不是数字类型
        MyStaticClass.method(55);
        MyStaticClass.method(89.9);
        MyStaticClass.eat(new Dog());
        MyStaticClass.eat(new Cat());//ERROR 猫没有实现Comparable接口
    }
}
class MyStaticClass{
    //泛型只支持数组类型
    public static<T extends Number> void method(T t){}
    //泛型只支持Animal对象以及实现Comparable接口
    public static<T extends Animal&Comparable> void eat(T t){}
}
abstract class Animal{}
class Dog extends Animal implements Comparable{
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}
class Cat extends Animal{}
class MyClass<T>{public void m1(T t){}}
interface MyInterface<T>{
    void m2(T t);
}
class MyImpClass implements MyInterface<String>{
    @Override
    public void m2(String s) {}
}

Collections工具类

概念：集合工具类，定义了存取以外的集合常用方法
方法：
public static void reverse(List<?> list);//反转集合中元素的顺序
public static void shuffle(List<?> list);//随机重置集合元素的顺序
public static void sort(List<T> list);//升序排序(必须实现Comparable接口)

LinkedList<Integer> list=new LinkedList<Integer>();
list.add(1);
list.add(3);
list.add(5);
list.add(7);
list.add(9);
Collections.shuffle(list);
Collections.reverse(list);
Collections.sort(list);
for(int i=0;i<list.size();i++){
    System.out.println(list.get(i));
}