Java中的集合一

本文的核心内容：Java中的集合List。

 

Collection集合体系的关系图

 

1：所有的集合接口和相关实现类都在java.util包里。

2：集合：存储多个对象

 

一：集合接口的特点

Collection  [无实现类]  该接口中的元素、返回值都是object类型

1、 接口特点

Collection 接口的特点是元素是 Object。遇到基本类型数据，需要转换为包装类对象。

2、 常用方法：    add(object o);   allAll(Collection  c);

                            clear();         contains(object o);

                            remove(object o);   size();

                            toArray();//转成数组

 

 

List 接口：元素按顺序进行存储，可以用下标进行访问集合。此集合的对象可以重复。

List 继承至Collection必然拥有Collection的所有抽象方法。

常用方法(多于Collection的)：

add(int pos,object o);   remove(int pos);

get(int pos);

indexOf(object o);  lastIndexOf(object o);

setList(int pos, object o);//设置某个位置的值

subList(int start,int end);  //返回一个集合

我们可以看出List可以通过下标来得到集合中的对象！

 

二：List接口实现类的遍历方法。

1：下标遍历（前提：必须获取集合里面对象的Size）

 

//遍历的同时，去除list中所有的"李白"

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("李白");
    list.add("李贺");
    list.add("杜甫");
    list.add("李白");
    print(list);
}
public  static  void print(List list)
{
    for(int i=0;i<list.size();i++)
    {
        Object o=list.get(i);
        String s=(String)o;
        if ("李白".equals(s)) {
            list.remove(i);
            continue;
        }
        System.out.println(s);
    }
}

 

上面的代码会有点小问题。因为list调用remove方法的后，list集合中对象的下标改变了。

解决办法：倒着删，这样就不会影响list集合中对象的下标。

for(int i=list.size()-1;i>0;i--)
{
    Object o=list.get(i);
    String s=(String)o;
    if ("李白".equals(s)) {
        list.remove(i);
        continue;
    }
    System.out.println(s);
}

2：迭代器遍历

//调用集合的

public  static  void print(Collection list)
{
    Iterator it=list.iterator();//创建迭代器
    while(it.hasNext())//如果迭代器不为空
    {
        Object o=it.next();//it.next()返回一个Object
        String s=(String)o;//强转为对应的类型
        if ("李白".equals(s)) {
            it.remove();//从迭代器中删除，同时list集合也将删除
           continue;
        }
        System.out.println(s);
    }
}

 

3：for循环遍历（JDK5）

该方法不能改变原有集合（不能对原有集合进行删除操作，只能遍历读取）

public  static  void print(Collection list)
{
    for(Object o:list)
    {
        String s=(String)o;
        System.out.println(s);
    }
}

 

4：forEach方法循环遍历（JDK8）

list.forEach()方法，利用接口回调的方式实现迭代。

public  static  void print(Collection list)
{
   //接口的回调传入Consumer
    list.forEach(new Consumer() {
       @Override
       //集合中的元素已由系统帮你拿出，定义你需要的操作
       public void accept(Object o) {
           String s=(String)o;
           System.out.println(s);
       }
   });
}

三：List接口的实现类

1：ArrayList

2：Vector （重量级，效率低，线程安全，每个方法都被设计为同步方法）

3：LinkedList  链表 查询慢，增删快。

                        addFirst(Object o);   addLast(Object o);

                        getFirst(Object o);    getLast(Object o);

                        removeFirst();       removeLast();

 

四：List接口实现对象排序

Collections类是一个工具类

①：Collections.sort(List list);

实现该方法的对象必须实现Comparable接口

String类已经实现了Comparable接口

public static void main(String[] args) {
    String [] s={"abc","xyz","opq","osd"};
    List list= Arrays.asList(s);
    Collections.sort(list);
    for(String l:s)
    {
        System.out.println(l);
    }
}

该方法的弊端：实现该接口的类只能有一套排序方案。

    public static void main(String[] args) {
        List<Student> list= Arrays.asList(
                new Student("Tom",12),
                new Student("Jack",20),
                new Student("Luc",15),
                new Student("Peter",8)
        );
        Collections.sort(list);
        for(Student l:list)
        {
            System.out.println(l);
        }
    }
}
class Student implements Comparable<Student>
{
    String name;
    int age;
    public Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    @Override
    public  int compareTo(Student s)
    {
        return this.age-s.age;//根据年龄从小到大排序
    }
    @Override
    public String toString(){
        return "[Student:name="+this.name+" age="+this.age+"]";
    }
}

②：Collections.sort(List list,Comparator c);

//if o1<o2  -1
//if o1=o2  0
//if o1>o2  1

Comparator<Student> c1=new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
};//定义比较器


Comparator<Student> c2=new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);//字符串可以//调用compareTo比较
    }
};
Collections.sort(list,c2);//可以根据需求改变排序方式

 

③：list.sort(Comparator c)  JDK8中

 

list直接调用方法，传入比较器即可。

 

Comparator 中抽象方法就一个comapre方法。

Comparator还有其他的默认方法[已经实现的方法]

Comparator<String> c=Comparator.naturalOrder();

//自然排序

Comparator<String> c3=c.reversed();//比较器反转