集合框架

集合概述:

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接口的子类。ArrayListArrayList 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);}}/*---java01java02java03java04----java04java03java02java01---*/

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）；