集合框架之单列结合

Collection是单列集合的顶层接口，Map是双列结合的顶层的接口，都挺重要的，掌握，不过有点多，需多练。附带一张图片


面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，就对对象进行存储。

集合就是存储对象最常用的一种方式.
数组和集合都是容器的区别？
1.数组长度固定，而集合长度是可变的

2.数组值可以存储对象，还可以存储基本数据类型;而集合只能存储对象

3.数组存储数据类型是固定的，而集合存储的数据类型不固定

集合类的特点：
集合只能存储对象
集合的长度是可变的
集合可以存储不同类型的对象
集合类框架
**Collection:顶层接口
|--->List:列表，元素是有序的(元素带角标索引)，可以有重复元素,可以有null元素。
|--->ArrayList(JDK1.2):底层的数据结构是数组数据结构，特点是查询速度快(因为带角标)，
但是增删速度稍慢,因为当元素多时，增删一个元素则所有元素的角标都得改变
线程不同步。默认长度是10，当超过长度时，按50%延长集合长度。

|--->LinkedList(JDK1.2):底层数据结构式链表数据结构(即后面一个元素记录前一个)，
特点：查询速度慢，因为每个元素只知道前面一个元素，但增删速度快
因为元素再多，增删一个，只要让其前后的元素重新相连即可
线程是不同步的。

|--->Vector(JDK1.0):底层数据结构是数组数据结构.特点是查询和增删速度都很慢。
默认长度是10，当超过长度时,按100%延长集合长度。
线程同步。
(Vector功能跟ArrayList功能一模一样，已被ArrayList替代)

**List使用注意！
|--->ArrayList:
(1)当往ArrayList里面存入元素没什么要求时，即只要求有序就行时；

(2)当往ArrayList里面存入元素要求不重复时，比如存入学生对象，当同名同姓时
视为同一个人，则不往里面存储。则定义学生对象时，需复写equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
则往ArrayList集合通过add存入学生对象时，集合底层自己会调用学生类的equals方法，
判断重复学生则不存入。
注：对于List集合，无论是add、contains、还是remove方法，判断元素是否相同，
都是通过复写equals方法来判断！

|--->LinkedList
(1)LinkLedist的特有方法：
boolean offerFirst(E e) 在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。
E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
(2)通过LinkLedist的特有方法，可以实现某些数据特殊方式的存取，比如堆栈和队列。

一般情况下，使用哪种List接口下的实现类呢？
如果要求增删快，考虑使用LinkedList
如果要求查询快，考虑使用ArrayList
如果要求线程安全，考虑使用Vector。

|--->Set:集合，元素是无序的(因为没有索引)，元素不可以重复。可以有null元素。
|--->HashSet(JDK1.2):底层数据结构是哈希表、存取速度快、元素唯一、线程不同步。
保证性元素唯一的原理:
先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true
(往HashSet里面存的自定义元素要复写hashCode和equals方法，
以保证元素的唯一性！)
|--->TreeSet:底层数据结构式二叉树。可以对Set集合中的元素进行排序。元素有序、线程不同步。
保证元素唯一性的依据：compareTo方法return 0
TreeSet排序的第一种方式:让元素自身具备比较性，比如八种基本数据类型或则字符串，
实现Compareble接口,覆盖compareTo方法，
此方式是元素的自然顺序

TreeSet排序的第一种方式:当元素自身不具备比较性(比如存储学生对象时)或者具备的
比较性不是我们所需要的比较性时(比如想字符串的长度排序),
此时就需要让集合自身具备自定义的比较性。
那如何让集合自身具备比较性呢？可在集合初始化时，
就让集合具备比较方式。即定义一个类，
实现Comparator接口，覆盖compare方法。

**Set集合使用注意事项：
(1)HashSet:
通过new的方式往HashSet里面存的元素的hashCode都不同，但通常我们定义对象，
比如学生对象时，虽然是new的两个学生对象，但是当他们name和age一样时，我们认为是
同一个对象，所以为了保证元素的唯一性，我们通常在往HashSet集合里面存储元素时，
在定义对象的类中通常复写hashCode和equals方法。
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}

HashSet是如何保证元素唯一性的呢？
**如果两元素的hashCode值不同，则不会调用equals方法
**如果两元素的hashCode值相同，则继续判断equals是否返回true；
**hashCode和equals方法虽然定义在自定义对象类里面，但不是我们手动调用
而是往HashSet集合里面存储元素的时候，集合底层自己调用hashCode和equals
它自己拿对象去判断，自己判断两元素是否是同一个元素。

(2)TreeSet:
TreeSet要求往里面存的元素具备比较性，否则会报错。
TreeSet排序的第一种方式:让元素自身具备比较性
定义对象类，实现Compareble接口,复写compareTo方法，此方式是元素的自然顺序
class Student implements Comparable
{
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象！");
Student stu = (Student)obj;
int num = this.age-stu.age;
if(num==0)
return this.name.compareTo(stu.name);
return num;
}
}
TreeSet排序的第一种方式:让集合具备比较性
当元素自身不具备比较性(比如存储学生对象时)或者具备的
比较性不是我们所需要的比较性时(比如想字符串的长度排序),
此时就需要让集合自身具备自定义的比较性。
那如何让集合自身具备比较性呢？可在集合初始化时，
就让集合具备比较方式。即定义一个类，
实现Comparator接口，覆盖compare方法。
class StringLengthComparator implements Comparator
{
public int compare(Object obj1,Object obj2)
{
String s1 = (String)obj1;
String s2 = (String)obj2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StringLengthComparator());
ts.add("addfg");
ts.add("dfg");
ts.add("agtuug");
ts.add("vgjkg");
sop(ts);
}
}
基本数据类型或字符串对象均实现了Comparable接口，故同种类型基本数据间具备比较性，即自然顺序。

下面是自己练习的例子

package collection;

/*

* 集合中顶层接口Collection中的抽象的方法

*

* 演示接口中,没有All的方法

*

* Collection 接口 = 自己的实现类对象();

* 实现类对象调用方法,运行的方法都是实现类重写

*/

import java.util.*;

public class CollectionDemo {

public static void main(String[] args) {

method();

}

/*

* 返回集合中存储元素的个数

* 集合的长度

* int size()

* 三种长度表示形式: 数组的length,字符串length() 集合的size()

*/

public static void method_5()

{

Collection coll=new ArrayList();

coll.add("abc");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

System.out.println(coll);//[abc, abc2, abc3, abc4]

//调用集合大方法size()，获取长度

int size=coll.size();

System.out.println(size);//4

}

/*

* 判断集合中是不是有元素（集合是否为空）

* boolean isEmpty()

* 如果集合中么有元素，返回true

* */

public static void method_4()

{

Collection coll=new ArrayList();

boolean b=coll.isEmpty();

System.out.println(b);//true

}

/*判断集合中是否包含指定元素

* boolean contains(Object obj)

* 如果指定的对象存在集合中返回true

* */

public static void method_3()

{

Collection coll=new ArrayList();

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

System.out.println(coll);

//集合调用方法contains，判断元素在不在集合中

boolean b=coll.contains("abc2");

System.out.println(b);//true

}

/*清空集合中的所有元素

* void clear()

* */

public static void method_2()

{

//创建Collection子类对象ArrayList

Collection coll=new ArrayList();

//向集合中添加元素

coll.add("abc");

coll.add("abd");

coll.add("abe");

coll.add("abf");

//调用集合方法clean()清空集合

coll.clear();

System.out.println(coll);//[]表示已清空

}

/*

* 移除集合中的元素

* boolean remove(Object obj)

* 传递一个对象，集合会移除已有对象，移除成功返回true

* */

public static void method_1()

{

Collection coll=new ArrayList();

coll.add("abc");

coll.add("acc");

coll.add("adc");

coll.add("aec");

System.out.println(coll);//[abc, acc, adc, aec]

//调用集合中的方法remove()，移除指定的元素

boolean b=coll.remove("adc");

System.out.println(b);//true

System.out.println(coll);//[abc, acc, aec]

}

/*

* 将元素添加到集合

* 将对象存储到集合

* boolean add(Object obj)什么对象都可以存储

* */

public static void method()

{

Collection coll=new ArrayList();

coll.add("abc1");

coll.add(123);

coll.add(false);

//提示：输出集合，看到了集合中存储对象

//但是，只能称为观看，不能为获取

System.out.println(coll);//[abc1, 123, false]

}

}

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

package collection;

/*

* Collection接口中带有All结尾方法

*/

import java.util.*;

public class CollectionDemo1 {

public static void main(String[] args) {

method();

}

/*

* 获取两个集合的交集

* boolean retainAll(Collection c)

* 返回值boolean类型：ture和false

* 看原始集合，调用者，里面的元素是不是变化啦，如果变化了就是true

* */

public static void method_3()

{

Collection co1=new ArrayList();

Collection co2=new ArrayList();

co1.add(1231);

co1.add(1232);

co1.add(1233);

co2.add(1231);

co2.add(1231);

co2.add(1233);

co2.add(4);

co2.add(67);

//集合co11调用方法retainAll（）传递co2

//将两个集合co1和co2中的相同元素,保存到co1中

boolean b=co1.retainAll(co2);

System.out.println(b);//true

System.out.println(co1);//[1231, 1233]

}

/*

* 移除两个集合相同的元素

* boolean removeall(Collection c)

* */

public static void method_2()

{

Collection col1=new ArrayList();

Collection col2=new ArrayList();

col1.add(1231);

col1.add(1232);

col1.add(1233);

col2.add(1232);

col2.add(1230);

col2.add(1231);

//集合col1调用方法removeAll传递col2

//移除的是col1,移除的是col1和col2中相同的元素

boolean b=col1.removeAll(col2);

System.out.println(b);//true

System.out.println(col1);//[1233]

System.out.println(col2);//[1232, 1230, 1231]

}

/*

* 判断一个集合中的元素,是否完全包含另一个集合中的元素

* boolean containsAll(Collection c)

*/

public static void method_1()

{

Collection col1=new ArrayList();

Collection col2=new ArrayList();

col1.add(1231);

col1.add(1232);

col1.add(1233);

col2.add(1231);

col2.add(1233);

//集合clo1调用方法containsAll,传递col2

//判断col2中的所有元素，是不是包含在col1中

boolean b=col1.containsAll(col2);

System.out.println(b);//true

}

/*

* 将一个集合添加到另一个集合中

* boolean addAll(Collection c)

* 方法,传递的是所有Collection类型的对象

* 传递Collection接口的实现类对象

* 向集合中添加一批对象

*/

public static void method()

{

Collection col1=new ArrayList();

Collection col2=new ArrayList();

col1.add("abc1");

col1.add("abc2");

col2.add("abc3");

col2.add(123);

col2.add(456);

col2.add(789);

//使用集合col1调用方法addAll传递col2

//将col2中的元素,添加到col1中

boolean b=col1.addAll(col2);

System.out.println(b);//true

System.out.println(col1);//[abc1, abc2, abc3, 123, 456, 789]

//小细节 add(Object obj)

//col1.add(col2);

//System.out.println(col1);[abc1, abc2, abc3, 123, 456, 789]

}

}

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

package collection;

/*

* 将集合转成数组

* 遍历数组->间接遍历集合

*

* 数据类型,集合中什么类型都存

* 转成后的数组呢,存储是什么类型, Object

*

* Collection接口定义方法

* Object[] toArray()

*/

import java.util.*;

public class CollectionDemo2 {

public static void main(String[] args) {

Collection coll=new ArrayList();

coll.add("abc");

coll.add("你");

coll.add(false);

coll.add(new Date());

//将集合转成数组,集合调用方法toArray()

Object[] obj=coll.toArray();

//循环遍历数组

for(int x=0;x<obj.length;x++)

System.out.println(obj[x]);

/*

* abc

你

false

//当前系统时间

Mon Oct 26 14:31:34 CST 2015

* */

}

}

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

package list;

import java.util.ArrayList;

import java.util.Iterator;

/*2015-10-25 13:28:34

* 集合嵌套存储

* 1个集合中,存储多个集合

* ArrayList中,存储了多个ArrayList

* 外层的ArrayList,和内ArrayList

* 大个集合,小个集合

* 小集合存储字符串

*/

public class ListTest3 {

public static void main(String[] args) {

//创建ArrayList集合,存储的是其他ArrayList集合

//小集合,存储的是字符串对象

ArrayList<ArrayList<String>> al=new ArrayList<ArrayList<String>>();

//创建小的ArrayList集合

ArrayList<String> a1=new ArrayList<String>();

ArrayList<String> a2=new ArrayList<String>();

//两个小集合,存储字符串

a1.add("君威");

a1.add("宝马");

a2.add("卡宴");

a2.add("路虎");

//小集合,存储到大集合中

al.add(a1);

al.add(a2);

//迭代器,迭代大集合,迭代出小集合

Iterator<ArrayList<String>> it=al.iterator();

while(it.hasNext())

{

//迭代器it.next()获取出来的是什么,是ArrayList集合,集合存储的是字符串

//使用集合对象接收next方法返回值

ArrayList<String> a=it.next();

//迭代小集合

Iterator<String> ita=a.iterator();

while(ita.hasNext())

{

//迭代器ita.next方法,获取出来的就是小集合中存储的字符串

System.out.println(ita.next());

/* 君威

宝马

卡宴

路虎*/

}

}

System.out.println("========for循环形式=================");

for(ArrayList<String> a:al)

{

for(String s : a)

{

System.out.println(s);

}

}

}

}

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

package linkedlist;

/*

* LinkedList集合自身特性

* 底层数据结构,链表结果 采用对象之间的地址记录

* 查询慢,增删快

* 线程不安全,运行速度快

*

* 特殊的功能,操作集合的开头和结尾

*/

import java.util.LinkedList;

public class LinkedListDemo {

public static void main(String[] args) {

method();

}

/*

* LinkedList在JDK1.6的后,增加一组新的方法

* 替换原有的方法

* boolean offerFirst(E e)

在此列表的开头插入指定的元素。

* offerFirst -> addFirst

* boolean offerLast(E e)

在此列表末尾插入指定的元素。

* offerLast -> addLast

* E peekFirst()

获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

* peekFirst -> getFirst

* boolean offerLast(E e)

在此列表末尾插入指定的元素。

* peekLast -> getLast

* E pollFirst()

获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

* pollFirst -> removeFirst

* E pollLast()

获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

* pollLast -> removeLast

*

* 获取功能和移除功能,在链表没有元素的时候,返回null不会出现异常

*/

public static void method_3()

{

LinkedList link=new LinkedList();

link.add(1);

link.add(2);

link.add(3);

link.add(4);

System.out.println(link);//[1, 2, 3, 4]

System.out.println(link.getFirst());//1获取到开头第一个元素1

Object o = link.peekFirst();

System.out.println(o);//1

System.out.println(link);

System.out.println(o);

o = link.pollFirst();

System.out.println(o);

System.out.println(link);

}

/*

* LinkedList特有功能

* E removeFirst()

移除并返回此列表的第一个元素。

* Object removeFirst() 获取并移除链表的开头元素

* E removeLast()

移除并返回此列表的最后一个元素。

* Object removeLast() 获取并移除链表的结尾元素

*/

public static void method_2()

{

LinkedList link=new LinkedList();

link.addFirst(1);

link.addFirst(2);

link.addFirst(3);

link.addFirst(4);

System.out.println(link);//[4, 3, 2, 1]

System.out.println("----------");

Object obj=link.removeFirst();

System.out.println(obj);//移除的元素

System.out.println(link);//[3, 2, 1]

obj=link.removeLast();

System.out.println(obj);//1

System.out.println(link);//[3, 2]

}

/*

* LinkedList特有功能

* E getFirst()

返回此列表的第一个元素。

* Object getFirst()获取链表开头元素

* E getLast()

返回此列表的最后一个元素。

* Object getLast() 获取链表的结尾元素

* 如果链表中,没有元素了,还要获取,抛出NoSuchElementException

*/

public static void method_1()

{

LinkedList link=new LinkedList();

link.addFirst(1);

link.addFirst(2);

link.addFirst(3);

link.addFirst(4);//现金后出

System.out.println(link);

Object obj=link.getFirst();

System.out.println(obj);//4获取集合中第一个元素

System.out.println(link);//[4, 3, 2, 1]

obj=link.getLast();

System.out.println(obj);//1获取集合中最后一个元素

System.out.println(link);//[4, 3, 2, 1]

}

/*

* LinkedList特有功能

* void addFirst(E e)

将指定元素插入此列表的开头。

* addFirst(Object o)将元素添加到链表的开头

* void addLast(E e)

将指定元素添加到此列表的结尾。

* addLast(Object o) 将元素添加到链表的结尾

*/

public static void method()

{

LinkedList link=new LinkedList();

link.add(1);

link.add(2);

link.add(3);

link.add(4);

link.addFirst("ABC");

System.out.println(link);//[ABC, 1, 2, 3, 4]

link.addLast("xx");

System.out.println(link);//[ABC, 1, 2, 3, 4, xx]

}

}