黑马程序员 Java集合框架Collection

最新推荐文章于 2024-09-20 20:19:35 发布

原创最新推荐文章于 2024-09-20 20:19:35 发布 · 509 阅读

CC 4.0 BY-SA版权

本文详细介绍了Java集合框架的基础知识，包括数组与集合的区别、集合类的特点、集合中通用方法的应用，以及如何操作List、Set集合。通过具体代码示例展示了如何使用ArrayList、LinkedList、HashSet和TreeSet，强调了迭代器与枚举在集合操作中的使用限制，并介绍了LinkedList的特殊方法。此外，文章还阐述了哈希表的工作原理和HashSet、TreeSet的排序机制。

------- android培训、java培训、期待与您交流！ ----------

一集合框架

1.面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2.数组和集合类同是容器，有何不同：

数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。

数组中可以存储基本数据类型，集合只能存储对象。

3.集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

4.每一个容器对数据的存储方式都有不同。这个存储方式我们称之为数据结构。

集合中德共性方法。

1.增加：boolean add(E e) ; 添加元素方法。

2.删除：boolean remove(Object o) ;从集合中移除单个元素。

boolean removeAll(Collection<?> c); 移除一堆元素。

void clear(); 清空集合中的元素。

3.查：Iterator<E> iterator(); 返回在此collection的元素上进行迭代的迭代器。

4.长度： int size()；返回集合中元素的大小。

5. Object[] toArray() ；把集合转成数组。

Collection

|--List:元素是有序的，元素可以重复。因为该集合体系有索引。

|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

|--LinkedList ：底层使用的是链表数据结构。特点：增删的速度很快，查询速度慢。

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了.

|--Set:元素是无序的。元素不可以重复。

二 List集合

List：特有方法。凡是可以操作脚标的方法都是该体系特有的方法。

增： add(index,element);

addAll(index Collection)

删 : remove(index)

改 : set(index,elements);

查 : get(index);

subList(from,to);

listIterator();

package Collection;
import java.util.*;
public class CollectionDemo {
	  public static void main(String[] args){
		   method_2();
	  }
	  public static void method_2(){
		  ArrayList  al = new ArrayList();
		   //添加元素
		   al.add("java01");
		   al.add("java02");
		   al.add("java03");
		   al.add("java04");
		   
		   ArrayList  al2 = new ArrayList();
		   //添加元素
		   al2.add("java03");
		   al2.add("java04");
		   al2.add("java05");
		   al2.add("java06");
		   //取两个集合中的交集，al中只保留交集元素
		 //  al.retainAll(al2);
		  // sop(al);
		   //移除两个集合交集的元素。
		   al.removeAll(al2);
		   sop(al);
	  }
	  public static void method_1(){
		   ArrayList  al = new ArrayList();
		   //添加元素
		   al.add("java01");
		   al.add("java02");
		   al.add("java03");
		   al.add("java04");
		   sop(al);  //打印集合中的元素
		   sop("size:"+al.size());  //打印集合长度
		   al.remove("java01");  //删除元素
		   sop("size:"+al.size()); 
		   sop(al);
		   al.clear();  //清空集合中的元素。
		   sop(al);
	  }
	  public static void sop(Object o){
		  System.out.println(o);
	  }

}

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。

所以在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有局限性的。只能对元素进行判断，取出，删除的操作。

如果想要其他的操作如添加，修改等，就需要使用其子接口：ListIterator。

该接口只能通过List集合的listIterator方法获取。

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。

其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

LinkedList类：

特有方法：

增：

addFirst(E e); 将指定元素插入此列表的开头。

addLast(E e); 将指定元素添加到此列表的结尾。

删：

removeFirst() ;移除并返回此列表的第一个元素。若列表为空，则抛出NosuchElementException异常

removeLast(); 移除并返回此列表的最后一个元素。同上的异常

获取：

getFirst(); 返回此列表的第一个元素。若列表为空，则抛出NosuchElementException异常

getLast(); 返回此列表的最后一个元素。

LinkedList升级后的方法：

增加：

offerFirst();

offerLast();

获取：

peekFirst(); 若列表为空，返回null；

peekLast(); 若列表为空，返回null；

删除：

poolFirst(); 若列表为空，返回null；

poolLast(); 若列表为空，返回null；

三 Set集合

1.Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

|--HashSet：底层数据结构是哈希表。线程不同步

HashSet是如何保证元素的唯一性的呢？

是通过元素的两个方法，hashCode和equals来完成。

如果元素的HashCode值相同，才会判断equals是否为true。

如果元素的HashCode不同。就不会调用equals方法。

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

|--TreeSet：底层数据结构是二叉树。保证元素唯一性的依据。

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。

TreeSet的第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

特点：可以对Set集合中的元素进行排序。

当两种排序都存在时，以比较起为主。

记住，当排序时，当主要条件相同时，一定要判断一下次要条件。

2.Set集合的功能和Collection是一致的。

3.Set集合取出方式只有一种就是迭代器。

哈希表：

1）哈希表是按照哈希值的大小进行排列的，如果两个哈希值不同，则大的值放后面；如果两个哈希值相同，则再用equals方法比较两个元素的对象是否相同，如果不同，则将第二个值顺延，两个值串起来，放在同一个位置上。

2）取值时是按照哈希值取出来的。

HashSet示例

package Collection;

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



public class HashSetDemo {
	  public static void main(String[] args){
		   HashSet hs = new HashSet();
		   hs.add(new Person("java01",11));
		   hs.add(new Person("java02",12));
		   hs.add(new Person("java01",11));
		   hs.add(new Person("java03",13));
		   
		    for(Iterator it =hs.iterator();it.hasNext();){
		    	 Person p = (Person)it.next();
		    	 System.out.println(p.getName()+"......"+p.getAge());
		    }
	  }

}
class Person {
	 private String name;
	 private int age;
	 
	 //定义构造方法，在学生创建时就赋予它基本信息(名字,成绩,总成绩)
	 Person(String name,int age){
		 this.name=name;
	     this.age=age;
	 }
	 public String getName(){
		 return this.name;
	 }
	 public int getAge(){
		 return this.age;
	 }
	 //重写hashCode方法
	 public int hashCode(){
		 System.out.println(this.name+".....hashcode");
		 return 60;
	 }
	 public boolean equals(Object o){
		  if(! (o instanceof Person))
			  return false;
		  
		  Person p  = (Person)o;
		  System.out.println(this.name+"equals"+p.name);
		  return this.name.equals(p.name)&&this.age==p.age;
		  
	 }
	 
}

TreeSet排序示例

package Collection;

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

public class TreeSetDemo {
	public static void main(String[] args){
		//第二种排序方式。就是让集合具有可比性
		TreeSet ts = new TreeSet(new Mycomparator());
		 ts.add(new Student("java01",40));
		 ts.add(new Student("java073",55));
		 ts.add(new Student("java02",20));
		 ts.add(new Student("java01",35));
		 ts.add(new Student("java013",55));
		 ts.add(new Student("java03",55));
		 
		 for(Iterator it = ts.iterator();it.hasNext();){
			 Student s =(Student)it.next();
			 System.out.println(s.getName()+"........."+s.getAge());
		 }
	}
	


}
//第一种排序方式。让元素自身实现可比性。
class Student implements Comparable{
    private String name;
    private int age;
    Student(String name,int age){
    	this.name=name;
    	this.age=age;
    }
    Student(){
    	
    }
    public String getName(){
    	return this.name;
    }
    public int getAge(){
    	return this.age;
    }
	@Override
	public int compareTo(Object o) {
		 if(!(o instanceof Student))
			 throw new RuntimeException("类型不匹配");
		 Student s = (Student)o;
		 int num = new Integer(this.age).compareTo(new Integer(s.getAge()));
		 if(num==0)
			 return this.name.compareTo(s.getName());
		return num;
	}
	
}
class Mycomparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Student s = (Student)o1;
		Student s2 = (Student)o2;
		int num = new Integer(s.getAge()).compareTo(new Integer(s2.getAge()));
		if(num==0)
			return s.getName().compareTo(s2.getName());
		return num;
	}
	 
}