Java笔记之集合框架（下）

集合类的由来：
   对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
   就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。

集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。

框架的顶层Collection接口：

Collection的常见方法：

1，添加。
   boolean add(Object obj):
   boolean addAll(Collection coll):

2，删除。
   boolean remove(object obj):
   boolean removeAll(Collection coll);
   void clear();

3，判断：
   boolean contains(object obj):
   boolean containsAll(Colllection coll);
   boolean isEmpty():判断集合中是否有元素。

4，获取：
   int size():
   Iterator iterator():取出元素的方式：迭代器。
   该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
   所以该迭代器对象是在容器中进行内部实现的。
   对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
   也就是iterator方法。

   Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
   其实就是抓娃娃游戏机中的夹子！


5，其他：
   boolean retainAll(Collection coll);取交集。
   Object[] toArray():将集合转成数组。

-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加
   void add(index,element);
   void add(index,collection);

2，删除；
Object remove(index):

3，修改：
Object set(index,element);

4，获取：
   Object get(index);
   int indexOf(object);
   int lastIndexOf(object);
   List subList(from,to);


list集合是可以完成对元素的增删改查。

List:
   |--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
   |--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
   |--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。



LinkedList:

   addFirst();
   addLast():
   jdk1.6
   offerFirst();
   offetLast();


   getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
   getLast();
   jdk1.6
   peekFirst();//获取但不移除，如果链表为空，返回null.
   peekLast():

   removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
   removeLast();
   jdk1.6
   pollFirst();//获取并移除，如果链表为空，返回null.
   pollLast();



作业：
1，自己去查文档演示Vector中的elements()方法。

2，LinkedList中的，addFirst addLast getFirst，getLast removeFirst removeLast。

3，既然集合是存储对象的，请定义ArryaList集合，并存储Person对象。如new Person("lisi",20);
并取出。将姓名和年龄打印出来。

---------------------------------------------

Set:元素不可以重复，是无序。
   Set接口中的方法和Collection一致。
   |--HashSet: 内部数据结构是哈希表，是不同步的。
       如何保证该集合的元素唯一性呢？
       是通过对象的hashCode和equals方法来完成对象唯一性的。
       如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
       如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
       如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

       记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
       一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
       建立对象判断是否相同的依据。

contains使用的是里面的equals方法

Person类

package cn.itcast.p.bean;

public class Person /*extends Object*/ implements Comparable {

	private String name;
	private int age;
	
	
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	
	
	@Override
	public int hashCode() {
//		System.out.println(this+".......hashCode");
		
		return name.hashCode()+age*27;
//		return 100;
	}
	@Override
	public boolean equals(Object obj) {
		
		if(this == obj)
			return true;
		if(!(obj instanceof Person))
			throw new ClassCastException("类型错误");
		
//		System.out.println(this+"....equals....."+obj);
		Person p = (Person)obj;
		
		
		
		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String toString(){
		return name+":"+age;
	}
	@Override
	public int compareTo(Object o) {
		
		Person p = (Person)o;
		
		int  temp = this.age-p.age;
		return temp==0?this.name.compareTo(p.name):temp;
		
//		int  temp = this.name.compareTo(p.name);
//		return temp==0?this.age-p.age:temp;
		
		/*
		if(this.age>p.age)
			return 1;
		if(this.age<p.age)
			return -1;	
		
		else{
			
			return this.name.compareTo(p.name);
		}
		*/
		
	}
	
}

测试类

package cn.itcast.p3.arraylist.test;

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

import cn.itcast.p.bean.Person;

/*
 * 定义功能去除ArrayList中的重复元素。
 */

public class ArrayListTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		
//		demo();
		
//		singleDemo();
		
		
		ArrayList al = new ArrayList();
		al.add(new Person("lisi1",21));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		al.add(new Person("lisi4",24));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		System.out.println(al);
		
		al = getSingleElement(al);
		
		
		System.out.println(al.remove(new Person("lisi2",22)));
		System.out.println(al);
		
		
		
		
	}

	/**
	 * 
	 */
	public static void singleDemo() {
		ArrayList al = new ArrayList();
		al.add("abc1");
		al.add("abc2");
		al.add("abc2");
		al.add("abc1");
		al.add("abc");
		System.out.println(al);
		
		al = getSingleElement(al);
		
		System.out.println(al);
		
		
	}

	public static ArrayList getSingleElement(ArrayList al) {
		
		//1,定义一个临时容器。
		ArrayList temp = new ArrayList();
		
		//2,迭代al集合。
		Iterator it = al.iterator();
		
		while(it.hasNext()){
			Object obj = it.next();
			
			//3,判断被迭代到的元素是否在临时容器存在。
			if(!temp.contains(obj)){
				temp.add(obj);
			}
		}
		
		return temp;
	}

	/**
	 * 
	 */
	public static void demo() {
		
//		al.add(5);//al.add(new Integer(5));
	}
	

}

使用LinkedHashSet子类可以保证set有序且唯一

HashSet hs=new LinkedHashSet();
hs.add("hiahia")；
hs.add("hee");
hs.add("nihao");
hs.add("xixi")；
Iterator it=hs.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

输出的是有序的

hiahia
hee
nihao
xixi

   |--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
               判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

               TreeSet对元素进行排序的方式一：
               让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

               如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
               可以使用TreeSet集合第二种排序方式二：
               让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
               将该类对象作为参数传递给TreeSet集合的构造函数。

if(this.hashCode()== obj.hashCode() && this.equals(obj))

哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。

2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。

注意：如果哈希值不同，是不需要判断equals。

posted @ 2019-02-22 18:08 yorkmass 阅读(121) 评论(0) 收藏举报

刷新页面返回顶部

yorkmass

I wanner be a nice coder

Java笔记之集合框架（下）

公告