java学习--集合（第一天）

声明：由于学习所用环境为JDK1.8,所有java代码均在JDK1.8环境中测试通过，如果环境发生变化，可能会有错误！

一、集合的概念与框架结构

1、集合：Java API所提供的一系列类的实例，可以用于动态存放多个对象。
     Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
     特点：长度不固定，只能存储引用类型对象
2、java集合框架

3、Collection接口中定义了一些集合常用方法

public static void main(String[] args) {
	List<String> list=new LinkedList<String>();
	Collections.addAll(list, "aa","bb","cc");
	showList(list);
	System.out.println("打乱之后：");
	Collections.shuffle(list);
    showList(list);	
    System.out.println("反转之后：");
    Collections.reverse(list);
    showList(list);
	}
	public static void showList(List<String> list){
		for(String str:list){
        	System.out.print(str+"  ");
        }
		System.out.println();
	}

4、存储特点：

Collection接口－定义了存取对象的方法。两个常用的子接口：
 List接口：存放的元素有序且允许有重复的集合接口。
 Set接口：存放的元素不包含重复元素的集合接口。
二、List集合及其实现类

List接口是Collection接口的子接口
实现List接口的集合类中的元素是有序的，且允许重复。
List集合中的元素都对应一个整数型的序号记载其在集合中的位置，可以根据序号存取集合中的元素。
JDK API所提供的List集合类常用的有 :ArrayList、LinkedList
1、List接口常用方法
List接口比Collection接口中新增的几个实用方法：
public Object get(int index);
返回列表中的元素数
public Object add(int index, Object element);
在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话）和所有后续元素向右移动
public Object set(int index, Object element) ;
用指定元素替换列表中指定位置的元素
public Object remove(int index);
移除列表中指定位置的元素
public ListIterator listIterator()
返回此列表元素的列表迭代器

2、实现类--ArrayList

ArrayList是使用数组结构实现的List集合。
优点：
对于使用索引取出元素有较好的效率，它使用索引来快速定位对象
缺点：
元素做删除或插入速度较慢、因为使用了数组，需要移动后面的元素以调整索引顺序。

public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("中国");
		list.add("俄罗斯");
		list.add("中国");
		list.add("意大利");
		for(int i=0;i<list.size();i++){
			System.out.print(list.get(i)+" ");
		}
		System.out.println();
		list.remove("中国");
		for(String str:list){
			System.out.print(str+" ");
		}
	}

3、实现类--LinkedList

LinkedList是使用双向链表实现的集合。
LinkedList新增了一些插入、删除的方法。
优点：对频繁的插入或删除元素有较好的效率
缺点：查询元素时，效率低，因为要从第一个元素查找。

public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList<String> list=new LinkedList<String>();
		System.out.println("模拟栈数据类型");
	    list.push("香港");
	    list.push("澳门");
	    list.push("厦门");
	    System.out.print(list.pop()+" ");
	    System.out.print(list.pop()+" ");
	    System.out.print(list.pop()+" ");
	    System.out.println();
	    System.out.println("模拟队列数据类型");
	    list.add("香港");
	    list.add("澳门");
	    list.add("厦门");
	    System.out.print(list.removeFirst()+" ");
	    System.out.print(list.removeFirst()+" ");
	    System.out.print(list.removeFirst()+" ");
	}

三、迭代器的使用

1、Iterator是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断，判断是否有内容，如果有内容则把内容取出。
Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作。
2、所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。
Iterator it = coll.iterator();
while(it.hasNext()){

      it.next();
}
3、Iterator接口中定义了如下方法：
boolean hasNext(); //判断游标右边是否有元素
Object next(); //返回游标右边的元素并将游标移动到下一个位置
4、另一种遍历集合的方法：
用增强for遍历集合中的元素
凡是能用 Iterator 迭代的集合都可以用JDK5.0中增强的for循环来更简便的遍历。
  List<String> list=new ArrayList<String>();
  …
eg: for(String data:list){
             System.out.print(data+”  ”)
      }

public class IteratorDemo {

	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<>();
		Collections.addAll(list,"西安","北京","厦门","西安","咸阳");
		Iterator<String> iter=list.iterator();   // 返回List集合的迭代器
		// 通过迭代器遍历集合
		while(iter.hasNext()){
			System.out.print(iter.next()+"  ");
		}

	}

三、泛型补充

1、泛型（Generic  type）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
泛型的好处：
解决了类型安全的问题(运行期出现“java.lang.ClassCastException”异常)
2、泛型类

class  Gen<T> {
    private T ob; // 定义泛型成员变量
 
    public Gen(T ob) {
        this.ob = ob;
    }
    public T getOb() {
        return ob;
    }
    public void setOb(T ob) {
        this.ob = ob;
    }
    public void showType() {
        System.out.println("T的实际类型是: " + ob.getClass().getName());
    }
}
3、受限泛型

1. 设置上限
      类名称<? extends 上限类>
       只能接收上限类对象或其子类对象
2. 设置下限
     类名称<?  super  下限类>
      接收下限类对象或其父类对象

注意：若定义泛型类，可以将?设置为泛型标识。

public class GenericDemo {

	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        for(String data:list){
        	System.out.print(data+"  ");
        }
        
        method(list);
        method(new ArrayList<Object>());
	}
	
	public static void method(List<? super String> list){
		List<String> temp=(List<String>)list;
		temp.add("abc");
	}
	
	

}

四、Set接口的实现类
Set接口没有提供Collection接口额外的方法，但实现Set接口的集合类中的 元素是不可重复的。
JDK API中所提供的Set集合类常用的有：
HashSet：散列存放
TreeSet：有序存放
LinkedHashSet
1、HashSet的存储原理

根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置(表元)中：
如果对应的位置没有其它元素，就只需要直接存入。
如果该位置有元素了，会将新对象跟该位置的所有对象进行比较(调用equals())，以查看是否已经存在了：还不存在就存放，已经存在就不存储。
2、HashSet的特点

(1) HashSet不保存元素的加入顺序。
 (2)HashSet接口存、取、删对象都有很高的效率。
 (3)对于要存放到HashSet集合中的对象，对应的类可以重写hashCode(Object obj)方法和equals()以实现对象相等规则的编写。

public class Student {
	private String name;
	private int age;

	public Student() {

	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		return this.age;
	}
	@Override
	public boolean equals(Object obj) {
		if(obj==null){
			return false;
		}else if(this==obj){
			return true;
		}else if(!(obj instanceof Student)){
			return false;
		}
		Student student=(Student)obj;
		if(this.name!=null && this.name.equals(student.name) && this.age==student.age){
			return true;
		}
		return false;
	} 
}

public class StudentHashSet {

	public static void main(String[] args) {
		HashSet<Student> set=new HashSet<>();
		set.add(new Student("李丽", 20));
		set.add(new Student("李梅", 22));
		set.add(new Student("李梅", 22));
		set.add(new Student("王梅", 22));
		for(Student stu:set){
	    System.out.print(stu);
	    System.out.println();
		}
		
	}

}

3、TreeSet集合的特点

(1)TreeSet:可以对加入其中的元素进行排序。但前提是必须指定排序规则。
(2)构造方法： public TreeSet()
    如果使用TreeSet的无参构造实例化TreeSet集合，则加入到TreeSet集合中的元素所对应的类必须实现java.lang. Comparable<T>接口，复写其中的int compareTo(T o)方法，并在方法中编写排序规则。
(3)在Comparable<T>接口的compareTo(T o)方法中，指定排序规则(以升序为例)：
 public int compareTo(Girl girl)｛
         if(this.xxx>girl.xxx){
                   return 1;
         }else if(this.xxx<girl.xxx){
                   return  -1;
        }else{
                   return 0;
        }
｝
TreeSet比较排序的过程，已经对重复元素去重了

public class Person implements Comparable<Person> {
	private String name;
	private int age;
	private double score;

	public Person() {

	}

	public Person(String name, int age, double score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}

	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 double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", score=" + score
				+ "]";
	}

	@Override
	public int compareTo(Person person) {
		if(this.score>person.score){
			return 1;
		}else if(this.score<person.score){
			return -1;
		}else{
			if(this.age>person.age){
				return 1;
			}else if(this.age<person.age){
				return -1;
			}else{
				return 0;
			}
		}
	}
}

public class PersonTreeSet {

	public static void main(String[] args) {
		TreeSet<Person> set=new TreeSet<Person>();
		set.add(new Person("李梅", 18, 89.9));
		set.add(new Person("王梅", 19, 89.9));
		set.add(new Person("张梅", 17, 80.9));
		set.add(new Person("赵梅", 18, 90.5));
		for(Person person:set){
		System.out.println(person);
		}
	}

}