集合框架

集合概述:

java中的集合对象就像一个容器,用来存放java类 的对象,java中的集合类有点方便存放和取出,有点方便查询

java.util包提供了一些集合类,又被称为容器,与数组相似,不同点是数组长度是固定的,集合长度是可变的.

常用集合有List集合,Set集合,Map集合,.List与Set继承了Collection接口,

Collection 层次结构 中的根接口:

Collection定义了集合框架的共性功能。
1，添加
add(e);
addAll(collection);

</pre>2，删除<span style="white-space:pre"></span>remove(e);<span style="white-space:pre"></span>removeAll(collection);<span style="white-space:pre"></span>clear();清空3，判断。<span style="white-space:pre"></span>contains(e);是否包含<span style="white-space:pre"></span>isEmpty();是否为空4，获取<span style="white-space:pre"></span>iterator();<span style="white-space:pre"></span>size();5，获取交集。<span style="white-space:pre"></span>retainAll();6，集合变数组。<span style="white-space:pre"></span>toArray();</div><div></div><div></div><pre name="code" class="java">import java.util.*;
class CollectionDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		//创建一个集合容器。使用Collection接口的子类。ArrayList
		ArrayList al = new ArrayList();

		//1，添加元素。
		al.add("java01");//add(Object obj);
		al.add("java02");
		al.add("java03");
		al.add("java04");

		//打印原集合。
		sop("原集合:"+al);


		//3，删除元素。
		//al.remove("java02");
		//al.clear();//清空集合。


		//4，判断元素。
		sop("java03是否存在:"+al.contains("java03"));
		sop("集合是否为空？"+al.isEmpty());


		//2，获取个数。集合长度。
		sop("size:"+al.size());

		//打印改变后的集合。
		sop(al);

	}
}

迭代器是取出方式，会直接访问集合中的元素。

所以将迭代器通过内部类的形式来进行描述。

通过容器的iterator()方法获取该内部类的对象。

import java.util.*;
class CollectionD 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		
		ArrayList al = new ArrayList();

		//1，添加元素。
		al.add("java01");//add(Object obj);
		al.add("java02");
		al.add("java03");
		al.add("java04");

		
		Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。

		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

List

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

Lsit的组成

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

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

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

二、List集合的特有方法（可以操作角标的方法）：

1. 增 
   
   • add(index,element);
   • addAll(index,Collection);
2. 删 
   
   • remove(index);
3. 改 
   
   • set(index,element);
4. 查 
   
   • get(index);
   • subList(from,to);
   • ListInterater();

LinkedList特有方法:

addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。


pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();

		link.addLast("java01");
		link.addLast("java02");
		link.addLast("java03");
		link.addLast("java04");

		//sop(link);
//		sop(link.getFirst());
//		sop(link.getFirst());
		//sop(link.getLast());
		//sop(link.removeFirst());
		//sop(link.removeFirst());

		//sop("size="+link.size());

		while(!link.isEmpty())
		{
			sop(link.removeLast());
		}

	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*

---
java01
java02
java03
java04

----
java04
java03
java02
java01
---
*/

set集合

set集合由set接口和set接口实现类组成,set接口继承了collection接口,包含collection所有方法

Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

class HashSetDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		
		HashSet hs = new HashSet();

		sop(hs.add("java01"));
		sop(hs.add("java01"));
		hs.add("java02");
		hs.add("java03");
		hs.add("java03");
		hs.add("java04");

		Iterator it = hs.iterator();

		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

|--TreeSet:可以对Set集合中的元素进行排序。底层数据结构是二叉树。
保证元素唯一性的依据： compareTo方法return 0.


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

class TreeSetDemo 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi08",19));
		//ts.add(new Student("lisi007",20));
		//ts.add(new Student("lisi01",40));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}


class Student implements Comparable//该接口强制让学生具备比较性。
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{

		//return 0;
		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		System.out.println(this.name+"....compareto....."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
		/**/
	}

	public String getName()
	{
		return name;

	}
	public int getAge()
	{
		return age;
	}
}

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

在集合初始化时，就有了比较方式即::比较器

class Student implements Comparable//该接口强制让学生具备比较性。
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{

		//return 0;
		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		//System.out.println(this.name+"....compareto....."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
		/**/
	}

	public String getName()
	{
		return name;

	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetDemo2 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi02",21));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi007",29));
		//ts.add(new Student("lisi007",20));
		//ts.add(new Student("lisi01",40));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

class MyCompare implements Comparator//比较器
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;

		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
		{

			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			/*
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge()==s2.getAge())
				return 0;
			return -1;
			*/
		}

		
		return num;

	}
}

Map集合

map没有继承collection接口,提供的是key到value的映射.每一个key映射一个value

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1，添加。
put(K key, V value) 
putAll(Map<? extends K,? extends V> m) 


2，删除。
clear() 
remove(Object key) 


3，判断。
containsValue(Object value) 
containsKey(Object key) 
isEmpty() 




4，获取。
get(Object key) 
size() 
values() 


entrySet() 
keySet() 


Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

import java.util.*;
class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		//添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
		//并put方法会返回被覆盖的值。
		System.out.println("put:"+map.put("01","zhangsan1"));
		System.out.println("put:"+map.put("01","wnagwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");

		System.out.println("containsKey:"+map.containsKey("022"));
		//System.out.println("remove:"+map.remove("02"));

		System.out.println("get:"+map.get("023"));

		map.put("04",null);
		System.out.println("get:"+map.get("04"));
		//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。


		
		//获取map集合中所有的值。
		Collection<String> coll = map.values();

		System.out.println(coll);
		System.out.println(map);


	}
}

和Set很像。
其实大家，Set底层就是使用了Map集合。

map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。



Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。




2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry


Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。

<pre name="code" class="java">public class MapTest {
    public static void main(String[] args) {
        //定义Map容器
        HashMap<Student, String> map = new HashMap<Student, String>();

        //存入内容
        map.put(new Student("Li", 22), "hebei");
        map.put(new Student("Zhao", 24), "shandong");
        map.put(new Student("Wang", 21), "beijing");
        map.put(new Student("Wang", 21), "beijing");

        //获取内容（1）entrySet
        Set<Map.Entry<Student, String>> entrySet = map.entrySet();

        for(Iterator<Map.Entry<Student, String>> it = entrySet.iterator();it.hasNext();){
            Map.Entry<Student, String> me = it.next();

            Student key = me.getKey();
            String value = me.getValue();

            System.out.println(key.getName()+"\t"+key.getAge()+"\t"+value);
        }

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

        //获取内容（2）keySet
        Set<Student> keySet = map.keySet();
        for(Iterator<Student> it = keySet.iterator();it.hasNext();){
            Student s = it.next();
            String addr = map.get(s);
            System.out.println(s.getName()+"\t"+s.getAge()+"\t"+addr);
        }
    }
}

泛型 ：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。好处1.将运行时期出现问题ClassCastException，转移到了编译时期。，方便于程序员解决问题。让运行时问题减少，安全。，2，避免了强制转换麻烦。泛型格式：通过<>来定义要操作的引用数据类型。通常在集合框架中很常见，只要见到<>就要定义泛型。<> 就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候，定义泛型来完成扩展。

1. 泛型类定义的泛型，在整个类中有效，如果被方法使用，泛型类的对象明确要操作的类型后，所有要操作的泛型就已经固定了。
2. 为了让不同的方法操作不同的类型，而且定义类型还不确定。那么就将泛型定义在方法上。

2.1 定义带类型参数的类

在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取
 值范围进行限定，多个类型参数之间用,号分隔。
 定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，
 就像使用普通的类型一样。
 注意，父类定义的类型参数不能被子类继承。
 public class TestClassDefine<T, S extends T> {
     ....  
 }

 2.2 定义待类型参数方法
 在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内,指定一个或多个类型参数的名字，
 同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。
 定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。
 例如：
 public <T, S extends T> T testGenericMethodDefine(T t, S s){
     ...
 }

通配符
 在上面两小节中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如
 List<?> unknownList;
 List<? extends Number> unknownNumberList;
 List<? super Integer> unknownBaseLineIntgerList; 
 注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素，
 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL

 List<String> listString;
 List<?> unknownList2 = listString;
 unknownList = unknownList2;
 listString = unknownList;//编译错误
 

 数组范型
 可以使用带范型参数值的类声明数组，却不可有创建数组
 List<Integer>[] iListArray;
 new ArrayList<Integer>[10];//编译时错误

集合工具类:注释-----------

集合工具类不熟练

集合框架的工具类。Collections:集合框架的工具类。里面定义的都是静态方法。Collections和Collection有什么区别？Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。 它有两个常用的子接口， List：对元素都有定义索引。有序的。可以重复元素。 Set：不可以重复元素。无序。Collections是集合框架中的一个工具类。该类中的方法都是静态的 提供的方法中有可以对list集合进行排序，二分查找等方法。 通常常用的集合都是线程不安全的。因为要提高效率。 如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的

<h2 id="二arrays" style="margin: 0.8em 0px; padding: 0px; box-sizing: border-box; font-weight: 100; color: rgb(85, 85, 85); font-family: 'microsoft yahei'; line-height: 35px;">Arrays</h2><h3 id="概念-4" style="margin: 0.8em 0px; padding: 0px; box-sizing: border-box; font-weight: 100; color: rgb(85, 85, 85); font-family: 'microsoft yahei'; line-height: 35px;"><a target=_blank name="t53" style="box-sizing: border-box; color: rgb(12, 137, 207);"></a>概念</h3><p style="margin-top: 0px; margin-bottom: 1.1em; padding-top: 0px; padding-bottom: 0px; box-sizing: border-box; color: rgb(85, 85, 85); font-family: 'microsoft yahei'; font-size: 14px; line-height: 35px;">用于操作数组对象的工具类，里面都是静态方法。</p><h3 id="方法-2" style="margin: 0.8em 0px; padding: 0px; box-sizing: border-box; font-weight: 100; color: rgb(85, 85, 85); font-family: 'microsoft yahei'; line-height: 35px;"><a target=_blank name="t54" style="box-sizing: border-box; color: rgb(12, 137, 207);"></a>方法</h3><p style="margin-top: 0px; margin-bottom: 1.1em; padding-top: 0px; padding-bottom: 0px; box-sizing: border-box; color: rgb(85, 85, 85); font-family: 'microsoft yahei'; font-size: 14px; line-height: 35px;">asList方法：将数组转换成list集合。 <br style="box-sizing: border-box;" />String[] arr = {“abc”,”kk”,”qq”}; <br style="box-sizing: border-box;" />List list = Arrays.asList(arr);//将arr数组转成list集合。</p>

for each

概念

java1.5版本后的新特性，是for的高级版。

格式

 for(数据类型变量名 :被遍历的集合（collection）或者数组) {执行语句}

与for的区别

• 高级for有一个局限性。必须有被遍历的目标（集合或数组）。
• 传统for遍历数组时有索引。
• 建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

for（int element ： a）//int element  其中的element相当于  for中的i，int是element的数据类型（我的个人理解不知道对不对~~）

　　　　System.out.println（element）；