黑马程序员---Java基础（集合）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

下面是有关集合视频的知识点总结：：

下面是有关集合的一些详细内容！

/*集合框架：为什么会出现这么多的容器呢？因为每一个容器对数据的存储方式都有不同。这个存储方式称之为：数据结构。1.add方法的参数类型是Object,以便于接受任意类型对象2.集合中存储的都是对象的引用（地址）什么是迭代器呢？其实就是集合的取出元素的方式。把取出方式定义在集合的内部。这样取出方式就可以直接访问集合内部的元素。取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都是共性内容，判断和取出。那么可以将共性抽取。那么这个内部类都符合一个规则。该规则就是Iterator.如何获取集合的取出对象呢？通过一个对外提供的方法，iterator();*/import java.util.*;class CollectionDemo {public static void main(String[] args) {System.out.println("Hello World!");}    public static void method_get() {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");al.add("java04");/*//获取迭代器，用于取出集合中的元素Iterator it = al.iterator();while (it.hasNext()) {sop(it.next());}*/for (Iterator it = al.iterator();it.hasNext() ; ) {sop(it.next());}}public static void method_2() {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");al.add("java04");ArrayList a2 = new ArrayList();a2.add("java01");a2.add("java02");a2.add("java05");a2.add("java06");//去交集，al中只会保留和a2中相同的元素。al.retainAll(a2);//al.removeAll(a2);sop("al="+al);sop("a2="+a2);}public static void base_method() {//创建一个集合容器，使用Collection接口的子类，ArrayListArrayList al = new ArrayList();//1.添加元素al.add("java01");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());//获取元素的个数sop("size:"+al.size());}public static void sop(Object obj) {System.out.println(obj);}}

/*Collection:   List:元素是有序的，元素可以重复，因为该集合体系有 索引       ArrayList:底层数组结构，特点：查询块，增删慢，线程不同步   LinkedList：底层是链表结构，特点：增删块，查询慢。   Vector：底层是数组结构，线程同步，被ArrayList取代了。   Set:元素是无序的，元素不可以重复。List：特有方法，凡是可以操作角标的方法都是该体系特有的方法。增：add(index,element);addAll(index,Collection);删：remove(index);改：set(index,element);查： get(index); subList(from,to); listIterator(); int indexOf(obj);获取指定元素的位置 ListIterator listIterator(); List集合特有的迭代器： ListIterator是Iterator的子接口。 在迭代时，不可以通过集合对象的方法操作集合 中的元素。因为会发生ConcurrentModificationException异常。 所以，在迭代器时，只能用迭代器的方法操作元素，可是， Iterator方法是有限的。 只能对元素进行判断，取出，删除的操作。 如果想要其他的操作如添加，修改等，就需要用 其子接口，ListIterator 该接口只能通过List集合的listIterator方法获取。枚举就是Vector特有的取出方式。发现枚举和迭代器很像，其实枚举和迭代器是一样的。因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。Vector v = new Vector();v.add("java01");v.add("java02");v.add("java03");v.add("java04");Enumeration en = v.elements();while (en.hasMoreElements()) {System.out.println(en.nextElement());}*/import java.util.*;class ListDemo {public static void main(String[] args) {//演示列表迭代器ArrayList al = new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");sop(al);ListIterator li = al.listIterator();while (li.hasNext()) {Object obj = li.next();if (obj.equals("java02")) {//li.add("java009");li.set("java006");}}sop(li.hasPrevious());while (li.hasPrevious()) {sop(li.previous());}//在迭代的过程中，准备添加或者删除元素/*Iterator it = al.iterator();while (it.hasNext()) {Object obj = it.next();if (obj.equals("java02")) {it.remove();//将java02的引用从集合中删除了。}sop("obj="+obj);}sop(al);*/}public static void method() {ArrayList al = new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");//在指定位置添加元素al.add(1,"java009");//删除指定位置的元素al.remove(2);//修改元素al.set(2,"java004");//通过角标获取元素sop("get(1)="+al.get(1));//获取所有的元素for (int x = 0;x < al.size() ;x++ ) {sop("al("+x+")="+al.get(x));}Iterator it = al.iterator();while (it.hasNext()) {sop("next="+it.next());}//通过indexOf获取对象的位置sop("index="+al.indexOf("java02"));List sub = al.subList(1,3);sop("sub="+sub);}public static void sop(Object obj) {System.out.println(obj);}}

/*LinkedList:特有方法；addFirst();addLast();getFirst();getLast();获取元素，但不删除元素，如果集合中没有元素会出现NoSuchElementException异常。removeFirst();removeLast();获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException异常。在JDK1.6出现了替代方法。offerFirst();offerLast();peekFirst();peekLast();获取元素，但是元素不删除，如果集合中没有元素，会返回null.pollFirst();pollLast();获取元素，但是元素被删除，如果集合中没有元素，会返回null.*/import java.util.*;class LinkedListDemo {public static void main(String[] args) {LinkedList link = new LinkedList();link.addFirst("java01");link.addFirst("java02");link.addFirst("java03");link.addFirst("java04");sop(link);/*打印结果：java04java03java02java01*/link.addLast("java01");link.addLast("java02");link.addLast("java03");link.addLast("java04");sop(link);/*打印结果：java01java02java03java04*///读取集合中的元素，输出while (!link.isEmpty()) {//sop(link.removeLast());//倒着取sop(link.removeFirst());//正着取} System.out.println("Hello World!");}public static void sop(Object obj) {System.out.println(obj);}}

/*练习题：使用LinkedList模拟一个堆栈或者队列数据结构堆栈：先进后出，如同一个杯子队列：先进先出  First in First out  FIFO 如同一个水管*/import java.util.*;class DuiLie {private LinkedList link;DuiLie() {link = new LinkedList();}public void myAdd(Object obj) {link.addFirst(obj);}public Object myGet() {return link.removeLast();}public boolean isNull() {return link.isEmpty();}}class LinkedListTest {public static void main(String[] args) {DuiLie d = new DuiLie();d.myAdd("java01");d.myAdd("java02");d.myAdd("java03");d.myAdd("java04");while (!d.isNull()) {sop(d.myGet());}}public static void sop(Object obj) {System.out.println(obj);}}

/*练习题：去除ArrayList集合中的重复元素。*/import java.util.*;class ArrayListTest {public static void main(String[] args) {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");al.add("java01");al.add("java02");al.add("java03");al.add("java03");al = singleElement(al);sop(al);}public static ArrayList singleElement(ArrayList al) {ArrayList newAl = new ArrayList();Iterator it = al.iterator();while (it.hasNext()) {Object obj = it.next();if (!newAl.contains(obj)) {newAl.add(obj);}}return newAl;}public static void sop(Object obj) {System.out.println(obj);}}

/*将自定义对象作为元素存到ArrayList集合中，并去除重复元素！比如：存入人对象，同性名，同年龄，视为同一个人，为重复元素。contains();remove();底层都是用的equals方法。*/import java.util.*;class Person {private String name;private int age;Person(String name,int age) {this.name = name;this.age = age;}public String getName() {return this.name;}public int getAge() {return this.age;}public boolean equals(Object obj) {if (!(obj instanceof Person)) {return false;}Person p = (Person)obj;return this.name.equals(p.getName()) && this.age == p.getAge();}}class  ArrayListTest2 {public static void main(String[] args) {ArrayList al = new ArrayList();al.add(new Person("zhangsan",29));al.add(new Person("li",29));al.add(new Person("zhangsan",29));al.add(new Person("li",28));al.add(new Person("zhangsan",28));al.add(new Person("li",29));al = singleElement(al);for (Iterator it = al.iterator();it.hasNext() ; ) {Person p = (Person)it.next();System.out.println(p.getName()+"...."+p.getAge());}}public static ArrayList singleElement(ArrayList al) {ArrayList newAl = new ArrayList();Iterator it = al.iterator();while (it.hasNext()) {Object obj = it.next();if (!newAl.contains(obj)) {newAl.add(obj);}}return newAl;}}

/*set:元素是无序(存入和取出的顺序不一定一致)，元素不可以重复   ---HashSet:底层数据结构是哈希表      HashSet是如何保证元素唯一性的呢？  是通过元素的两个方法，hashCode和equals来完成。  如果元素的HashCode值相同，才会判断equals是否为true.          如果元素的hashcode值不同，不会调用equals.  注意：对于判断元素是否存在，以及删除等操作，  依赖的方法是元素的hashCode和equals方法。   ---TreeSet：Set集合的功能和Collection是一致的。*/import java.util.*;class HashSetDemo {public static void main(String[] args) {HashSet hs = new HashSet();sop(hs.add("java01"));   //truesop(hs.add("java01"));  //false（地址值和内容都是一样的）hs.add("java02");        hs.add("java03");hs.add("java05");hs.add("java04");for (Iterator it = hs.iterator();it.hasNext() ; ) {sop(it.next());}}public static void sop(Object obj) {System.out.println(obj);}}

<pre name="code" class="java">/*set:元素是无序(存入和取出的顺序不一定一致)，元素不可以重复   ---HashSet:底层数据结构是哈希表      HashSet是如何保证元素唯一性的呢？  是通过元素的两个方法，hashCode和equals来完成。  如果元素的HashCode值相同，才会判断equals是否为true.      如果元素的hashcode值不同，不会调用equals.  注意：对于判断元素是否存在，以及删除等操作，  依赖的方法是元素的hashCode和equals方法。   ---TreeSet：Set集合的功能和Collection是一致的。练习题：往HashSet集合中存入自定对象。姓名和年龄相同为同一个人，重复元素*/import java.util.*;class HashSetTest {public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("li",19));hs.add(new Person("li",20));hs.add(new Person("zhang",19));hs.add(new Person("li",19));hs.add(new Person("zhang",19));hs.add(new Person("zhang",20));//sop("a1:"+hs.contains(new Person("li",20)));hs.remove(new Person("zhang",19));for (Iterator it = hs.iterator();it.hasNext() ; ) {Person p = (Person)it.next();sop(p.getName()+"......"+p.getAge());}}public static void sop(Object obj) {System.out.println(obj);} }class Person {private String name;private int age;Person(String name,int age) {this.name = name;this.age = age;}public int hashCode() {System.out.println(this.name+"...hashCode.."+this.age);return this.name.hashCode() + age;}public boolean equals(Object obj) {if (!(obj instanceof Person)) {return false;}Person p = (Person)obj;                System.out.println(this.name+"..equals.."+this.age);return this.name.equals(p.getName()) && this.age == p.getAge();}public String getName() {return this.name;}public int getAge() {return this.age;}}

<pre name="code" class="java">/*TreeSet：可以对Set集合中的元素进行排序底层数据结构是二叉树。保证元素唯一性的依据。compareTo方法return 0;TreeSet排序的第一种方式，让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也称为元素的自然顺序，或者叫做默认顺序。TreeSet的第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。需求：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。记住：排序时，当主要条件相同时，一定要判断一下次要条件。*/import java.util.*;class TreeSetDemo {public static void main(String[] args) {TreeSet ts = new TreeSet();ts.add(new Student("li20",20));ts.add(new Student("li21",21));ts.add(new Student("li22",22));ts.add(new Student("li23",22));ts.add(new Student("li19",19));ts.add(new Student("li24",24));for (Iterator it = ts.iterator();it.hasNext() ; ) {Student s = (Student)it.next();System.out.println(s.getName()+"......"+s.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 1; //按照存入元素的顺序输出   return 0；//按照存入元素的相反顺序输出}*/public int compareTo(Object obj) {if (!(obj instanceof Student)) {throw new RuntimeException("不是本类对象");}Student s = (Student)obj;System.out.println(this.name+"..compareTo1.."+s.name);if (this.age > s.age) {return 1;}if (this.age == s.age) {System.out.println(this.name+".......compareTo2......"+s.name);return this.name.compareTo(s.name);}return -1;}public String getName() {return this.name;}public int getAge() {return this.age;}}

<pre name="code" class="java">/*TreeSet的第二种排序方式。当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。当两种排序都存在时，以比较器为主。定义一个类，实现Comparator接口，覆盖compare方法。*/import java.util.*;class TreeSetDemo2 {public static void main(String[] args) {TreeSet ts = new TreeSet(new myCompare());ts.add(new Student("cisi11",11));ts.add(new Student("bisi12",12));ts.add(new Student("bisi12",12));ts.add(new Student("aisi13",13));ts.add(new Student("eisi11",12));ts.add(new Student("eisi11",13));ts.add(new Student("lisi14",14));sop(ts.size());for (Iterator it = ts.iterator();it.hasNext() ; ) {Student s = (Student)it.next();sop(s.getName()+"--ts--main--"+s.getAge());}}public static void sop(Object obj) {System.out.println(obj);}}class myCompare implements Comparator {public int compare(Object  o1,Object o2) {Student s1 = (Student)o1;Student s2 = (Student)o2;int i = s1.getName().compareTo(s2.getName());/*if (i > 0) {return 1;}else if (i == 0) {return s1.getAge() - s2.getAge();}else {return -1;}*/if (i == 0) {/*if (s1.getAge() > s2.getAge()) {return 1;}else if (s1.getAge() == s2.getAge()) {return 0;}else {return -1;}*/return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));}return i;}}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) {if (!(obj instanceof Student)) {throw new RuntimeException("不是本类对象");}Student s = (Student)obj;if (this.getAge() > s.getAge()) {return 1;}else if (this.getAge() == s.getAge()) {return this.getName().compareTo(s.getName());}else {   return -1;}}public String getName() {return this.name;}public int getAge() {return this.age;}

}

<pre name="code" class="java">/*练习题：按照字符串的长度排序字符串本身具备比较性，但是它的方式不是所需要的。这时就只能使用比较器。*/import java.util.*;class TreeSetDemo3 {public static void main(String[] args) {TreeSet ts = new TreeSet(new StrLenComparator());/*//这是用匿名内部类的书写形式TreeSet ts = new TreeSet(new StrLenComparator() {public int compare(Object o1,Object o2) {String s1 = (String)o1;String s2 = (String)o2;       if (s1.length() > s2.length()) {return 1;}else if (s1.length() == s2.length()) {return s1.compareTo(s2);}else {return -1;}int num = new Integer(s1.length()).compareTo(s2.length());if (num == 0) {return s1.compareTo(s2);}return num;    }});*/ts.add("a");ts.add("ad");ts.add("ac");ts.add("ac");ts.add("ssdf");ts.add("afgh");ts.add("asadf");for (Iterator it = ts.iterator();it.hasNext() ; ) {System.out.println(it.next());}}}class StrLenComparator implements Comparator {public int compare(Object o1,Object o2) {String s1 = (String)o1;String s2 = (String)o2;       /*if (s1.length() > s2.length()) {return 1;}else if (s1.length() == s2.length()) {return s1.compareTo(s2);}else {return -1;}*/int num = new Integer(s1.length()).compareTo(s2.length());if (num == 0) {return s1.compareTo(s2);}return num;}}

<pre name="code" class="java">/*泛型类什么时候定义泛型类?当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。*/class Person {}class Student {}//泛型前做法class Tool {private Object obj;public void setObject(Object obj) {this.obj = obj;}public Object getObject() {return obj;}}//泛型后做法class Utils<QQ> {private QQ q;public void setObject(QQ q) {this.q = q;}public QQ getObject() {return q;}}class GenericDemo3 {public static void main(String[] args) {Utils<Worker> u = new Utils<Worker>();u.setObject(new Person());Worker w = u.getObject();/*Tool t = new Tool();t.setObject(new Student());Worker w = (Worker)t.getObject();*/}}

/*泛型类定义的泛型，在整个类中有效，如果被方法使用。那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。*/class Demo<T> {public void show(T t) {System.out.println("show:"+t);}public <Q> void print(Q q) {System.out.println("print:"+q);}public static <W> void method(W t) {System.out.println("method:"+t);}}class GenericDemo4 {public static void main(String[] args) {Demo<String> d = new Demo<String>();d.show("haha");d.print(5);Demo.method("hahahahaahhaha");System.out.println("Hello World!");}}//泛型定义在接口上interface Inter<T> {void show(T t);}class InterImpl<T> implements Inter<T> {public void show(T t) {System.out.println("show:"+t);}}class GenericDemo5 {public static void main(String[] args) {InterImpl<Integer> i = new InterImpl<Integer>();i.show(4);}}

<pre name="code" class="java">/*? 通配符。也可以理解为占位符泛型的限定：? extends E:可以接收E类型或者E的子类型。上限? extends E:可以接收E类型或者E的父类型。下限*//*import java.util.*;class GenericDemo6 {public static void main(String[] args) {ArrayList<Integer> al1 = new ArrayList<Integer>();al1.add(4);al1.add(7);al1.add(1);printColl(al1);}public static void printColl(ArrayList<?> al) {Iterator<?> it = al.iterator();while (it.hasNext()) {//length方法是具体类型的方法，如果？是Integer,//则没有length方法，泛型好处是扩展，不好的是//他不能使用类型的特有方法。//System.out.println(it.next().length());}}}*///? extends E:可以接收E类型或者E的子类型。上限import java.util.*;class GenericDemo6 {public static void main(String[] args) {ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("abc1"));al.add(new Person("abc2"));al.add(new Person("abc3"));al.add(new Student("abc----4"));printColl(al);ArrayList<Student> al1 = new ArrayList<Student>();//错(实际参数列表和形式参数列表长度不同)//al1.add(new Person("abc4"));al1.add(new Student("abc---1"));al1.add(new Student("abc---2"));al1.add(new Student("abc---3"));printColl(al1); }    //泛型限定，只能接受Person,和Person的子类型。public static void printColl(ArrayList<? extends Person> al) {Iterator<? extends Person> it = al.iterator();while (it.hasNext()) {System.out.println(it.next().getName());}}}class Person {private String name;Person(String name) {this.name = name;}public String getName() {return this.name;}}class Student extends Person{Student(String name) {super(name);}}/*TreeSet(Comparator<? super E> comparator);?可以为E或者E的父类class Student implements Comparable<Person> { //<? super E>public int compareTo(Person s) {return this.getName().compareTo(s.getName());}}class Comp implements Comparator<Person> {public int compare(Person s1,Person s2) {//Person s1 = new Student("abc1");return s1.getName().compareTo(s2.getName());}}TreeSet<Student> ts = new TreeSet<Student>(new Comp());ts.add(new Student("abc1"));ts.add(new Student("abc2"));ts.add(new Student("abc3"));*/ 

/*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();Map:HashTable:底层是哈希表数据结构，不可以存入      null键null值，该集合是线程同步的，jdk1.0 效率低HashMap:底层是哈希表数据结构，允许使用null键，null值     该集合是不同步的，将HashTable替代，jdk1.2 效率高TreeMap:底层是二叉树数据结构，线程不同步，可以用于给        map集合中的键进行排序。和set很像：其实Set底层就是使用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","wangwu"));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);}}

/*map集合的两种取出方式：1.keySet:将map中所有的键存入到Set集合中，因为set具备迭代器。所有可以迭代方式取出所有的键，根据get方法，获取每一个键对应的值。Map集合的取出原理：将map集合转成set集合，在通过迭代器取出。2.entrySet:Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是Map.EntryMap.Entry 其实Entry也是一个接口，他是Map接口中的一个内部接口。interface Map{public static interface Entry{public abstract Object getKey();public abstract Object getValue();}}class HashMap implements Map{class Hahs implements Map.Entry{public Object getKey(){}public Object getValue(){}}}*/import java.util.*;class MapDemo2 {    public static void main(String[] args) {Map<String,String> map = new HashMap<String,String>();map.put("01","zhangsan1");map.put("02","zhangsan2");map.put("03","zhangsan3");map.put("04","zhangsan4");Set<Map.Entry<String,String>> entrySet = map.entrySet();Iterator<Map.Entry<String,String>> it = entrySet.iterator();while (it.hasNext()) {Map.Entry<String,String>  me = it.next();String key = me.getKey();String value = me.getValue();System.out.println(key+"..."+value);}/*//先获取map集合的所有键的Set集合，keySet();Set<String> keySet = map.keySet();//有了Set集合，就可以获取其迭代器。Iterator<String> it = keySet.iterator();while (it.hasNext()) {String key = it.next();//有了键就可以通过map集合的get方法获取//其对应的值。String value = map.get(key);System.out.println("key:"+key+",value:"+value);}*/}}

/*每一个学生都有对应的归属地。学生Student,地址String.学生属性：姓名，年龄。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。1.描述学生2.定义map容器，将学生作为键，地址作为值，存入3.获取map集合中的元素。*/import java.util.*;class Student implements Comparable<Student> {private String name;private int age;Student(String name,int age) {this.name = name;this.age = age;}public int hashCode() {return this.name.hashCode() + this.age;}public boolean equals(Object obj) {if (!(obj instanceof Student)) {throw new RuntimeException("不是本类对象！！");}Student s = (Student)obj;return this.name.equals(s.name) && this.age == s.age;}public int compareTo(Student s) {int num = this.name.compareTo(s.name);if (num == 0) {return new Integer(this.age).compareTo(new Integer(s.age));}return num;}public String getName() {return this.name;}public int getAge() {return this.age;}public String toString() {return this.name +".."+this.age;}}class HashMapDemo {public static void main(String[] args) {HashMap<Student,String> hm = new HashMap<Student,String>();hm.put(new Student("li021",21),"beijing");hm.put(new Student("li022",22),"beitianjin");hm.put(new Student("li022",22),"tianjin");hm.put(new Student("li019",19),"shanghai");hm.put(new Student("li024",24),"shandong");Set<Student> s = hm.keySet();for (Iterator<Student> it = s.iterator();it.hasNext() ; ) {Student stu = it.next();System.out.println("keySet:="+stu+".."+hm.get(stu));}Set<Map.Entry<Student,String>> se = hm.entrySet();for (Iterator<Map.Entry<Student,String>> it = se.iterator();it.hasNext() ; ) {Map.Entry<Student,String> me = it.next();Student s1 = me.getKey();String adr = me.getValue();System.out.println("entrySet:="+s1.getName()+".."+s1.getAge()+"....."+adr);}}}

/*需求：对学生对象的年龄进行升序排序因为数据是以键值对形式存在的。所以要使用可以排序的Map集合，TreeMap.*/import java.util.*;class TreeMapDemo {public static void main(String[] args) {TreeMap<Student,String> ts = new TreeMap<Student,String>(new StuNameCom());ts.put(new Student("alisi019",19),"beijing");ts.put(new Student("lisi020",20),"shanghai");ts.put(new Student("blisi018",18),"tianjin");ts.put(new Student("lisi020",20),"nanjing");ts.put(new Student("slisi022",22),"guangzhou");Set<Map.Entry<Student,String>> s = ts.entrySet();for (Iterator<Map.Entry<Student,String>> it = s.iterator();it.hasNext() ; ) {Map.Entry<Student,String> me = it.next();Student stu = me.getKey();String value = me.getValue();System.out.println(stu.getName()+".."+stu.getAge()+"...."+value);}}}//按照学生的年龄进行升序排序class StuNameCom implements Comparator<Student> {public int compare(Student s1,Student s2) {int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));if (num == 0) {return s1.getName().compareTo(s2.getName());}return num;} }class Student implements Comparable<Student> {private String name;private int age;Student(String name,int age) {this.name = name;this.age = age;}public int hashCode() {System.out.println(this.name+"--hashcode");return this.name.hashCode() + this.age;}public boolean equals(Object obj) {if (!(obj instanceof Student)) {throw new RuntimeException("不是本类对象！！");}System.out.println(this.name+"--equals");Student s = (Student)obj;return this.name.equals(s.name) && this.age == s.age;}    //先已姓名进行排序，public int compareTo(Student s) {int num = this.name.compareTo(s.name);if (num == 0) {return new Integer(this.age).compareTo(new Integer(s.age));}return num;}public String getName() {return this.name;}public int getAge() {return this.age;}public String toString() {return this.name +".."+this.age;}}

/*练习题："sdfgzxcuasdfxcvdf"获取该字符串中的字母的出现次数。希望打印结果;a(1)c(2)...通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。注意了，当发现有映射关系时，可以选择map集合。因为map集合中存放的就是映射关系。什么时候使用map集合呢？当数据之间存在映射关系时，就要先想map集合。思路：1.将字符串转换成字符数组，因为要对每一个字母进行操作。2.定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。3.遍历字符数组。将每一个字母作为键去查map集合。如果返回null,将该字母和1存入map集合中。如果返回不是null,说明该字母在map集合已经存在并有对应次数。那么就获取该次数并进行自增，然后将该字母和自增次数存入到map集合中，覆盖掉原来键所对应的值。4.将map集合中的数据变成指定的字符串形式返回。*/import java.util.*;class MapTest3 {public static void main(String[] args) {String s = "sdfg,.zxcuas/?dfxcdfg<<>2vdf";char[] c = s.toCharArray();TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();Set<Character> keySet = tm.keySet();for (int i = 0;i < c.length ;i++ ) {//计算字母出现的次数，不包括特殊字符if (c[i] >= 'a' && c[i] <= 'z' || c[i] >='A' && c[i] <= 'z') {if (!(tm.containsKey(c[i]))) {tm.put(c[i],1);} else {  int count = tm.get(c[i]) + 1;  tm.put(c[i],count);}}}Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();Iterator<Map.Entry<Character,Integer>> iter = entrySet.iterator();while (iter.hasNext()) {Map.Entry<Character,Integer> me = iter.next();System.out.print(me.getKey()+"("+me.getValue()+")");}//Iterator<Character> it = keySet.iterator();}}/*方法二：*/   import java.util.*;class TreeMapTest {public static void main(String[] args) {System.out.println(charCount("adsj,.fg./sg;'h"));}public static String charCount(String str) {char[] chs = str.toCharArray();TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();  int count = 0;for (int x = 0;x < chs.length ;x++ ) {if (chs[x] >= 'a' && chs[x] <= 'z' || chs[x] >= 'A' && chs[x] <= 'Z') {Integer value = tm.get(chs[x]);if (value != null) {count = value;}count++;tm.put(chs[x],count);count = 0;/*if (value==null) {tm.put(chs[x],1);}else {value = value + 1;tm.put(chs[x],value);}*/}}StringBuilder sb = new StringBuilder();Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();while (it.hasNext()) {Map.Entry<Character,Integer> me = it.next();Character ch = me.getKey();Integer value = me.getValue();sb.append(ch+"("+value+")");}return sb.toString();}}

/*map扩展知识：map集合被使用是因为具备映射关系，"yure","01","zhangsan""yure","02","lsi""jiuye","01","wangwu""jiuye","02","zhaoliu"*/import java.util.*;class MapTest {public static void main(String[] args) {HashMap<String,String> yure = new HashMap<String,String>();yure.put("01","zhangsan");yure.put("02","lisi");yure.put("03","wagnwu");HashMap<String,String> jiuye = new HashMap<String,String>();jiuye.put("01","zhaoliu");jiuye.put("02","fengqi");jiuye.put("03","chengba");HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();czbk.put("yure",yure);czbk.put("jiuye",jiuye);        Iterator<String> iter = czbk.keySet().iterator();while (iter.hasNext()) {String room = iter.next();System.out.println(room);HashMap<String,String> hm = czbk.get(room);getInfo(hm);}//getInfo(jiuye);}public static void getInfo(HashMap<String,String>  hm) {Iterator<String> iter = hm.keySet().iterator();while (iter.hasNext()) {String key = iter.next();System.out.println(key+".."+hm.get(key));}}}

/*第二种比较常用的实现方式：*/import java.util.*;class MapTest1 {public static void main(String[] args) {HashMap<String,List<Student1>> hm = new HashMap<String,List<Student1>>();List<Student1> yure = new ArrayList<Student1>();yure.add(new Student1("01","zhangsan"));yure.add(new Student1("02","lisi"));yure.add(new Student1("03","wangwu"));List<Student1> jiuye = new ArrayList<Student1>();jiuye.add(new Student1("01","zhaoliu"));jiuye.add(new Student1("02","fengqi"));jiuye.add(new Student1("03","chengba"));hm.put("yure",yure);hm.put("jiuye",jiuye);Iterator<String> iter = hm.keySet().iterator();while (iter.hasNext()) {String key = iter.next();System.out.println(key);getInfo(hm.get(key));}//getInfo(yure);}public static void getInfo(List<Student1> roomName) {for (Iterator<Student1> iter = roomName.iterator();iter.hasNext() ; ) {Student1 s1 = iter.next();System.out.println(s1);}}}class Student1 {private String id;private String name;Student1(String id,String name) {this.id = id;this.name = name;}public String toString() {return this.id + ":::" + this.name;}}

/*集合框架的工具类：Collections:*/import java.util.*;class CollectionsDemo {public static void main(String[] args) {List<String> list = new ArrayList<String>();list.add("abcd");list.add("aaa");list.add("zz");list.add("kkkkk");list.add("qq");list.add("z");Collections.sort(list);sop(list);//String max = Collections.max(list /*,new StrLenComparator()*/);//sop("max="+max);//手动实现二分查找，//int index = halfSearch(list,"aaa",new StrLenComparator());int index = Collections.binarySearch(list,"aaaa");sop("index="+index);//System.out.println("Hello World!");}public static int halfSearch(List<String> list,String key,Comparator<String> cmp) {int max = list.size() - 1;int min = 0;int mid;while (min <= max) {mid = (max + min) >> 1;String str = list.get(mid);int num = cmp.compare(str,key);if (num > 0) {max = mid - 1;}else if (num < 0) {  min = mid + 1;}else {return mid;}return -min-1;}}public static void sop(Object obj) {System.out.println(obj);}}class StrLenComparator implements Comparator<String> {public int compare(String s1,String s2) {if (s1.length() > s2.length()) {return 1;}if (s1.length() < s2.length()) {return -1;}return s1.compareTo(s2);}}

/*Collections-reverseOrder*/import java.util.*;class StrComparator implements Comparator<String> {/*int num = s1.compareTo(s2);if (num > 0) {return -1;}ele if (num < 0) {return 1;}else {return num;}*/return s2.compareTo(s1);}class StrLenComparator implements Comparator<String> {public int compare(String s1,String s2) {if (s1.length() > s2.length()) {return 1;}if (s1.length() < s2.length()) {return -1;}return s1.compareTo(s2);}}class CollectionDemo2 {public static void main(String[] args) {orderDemo();System.out.println("Hello World!");}public static void orderDemo() {TreeSet<String> ts = new TreeSet<String>(Collection.reverseOrder(new StrLenComparator()));ts.add("abcde");ts.add("aaa");ts.add("k");ts.add("cc");Iterator it = ts.iterator();while (it.hasNext()) {System.out.println(it.next());}}}

/*数组变集合：Arrays:用于操作数组的工具类。里面都是静态方法。*/class ArraysDemo {public static void main(String[] args) {//int[] arr = {2,4,5};//System.out.println(Arrays.toString(arr));String[] arr = {"abc","cc","kkkk"};//把数组变成List集合有什么好处？/*可以使用集合的思想和方法来操作数组中的元素。注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。contains.getindexOf();subList();如果你增删，那么会发生UnsupportedOperationException.*/List<String> list = Arrays.asList(arr);sop("contains:"+list.contains("cc"));list.add("qq");//UnsupportedOperationException.sop(list);//int[] nums = {2,4,5};//List<int[]> li = Arrays.asList(nums);//sop(li);打印结果为：地址值Integer[] nums = {2,4,5};List<Integer> li = Arrays.asList(nums);//sop(li);打印结果为：[2,4,5]/*如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。*/}public static boolean myContains(String[] arr,String key) {for (int x = 0;x < arr.length ;x++ ) {if (arr[x].equals(key)) {return true;}}return false;}public static void sop(Object obj) { System.out.println(obj);}}

/*集合变数组：Collection接口中的toArrays方法。*/import java.util.*;class CollectionToArray {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");/*1.指定类型的数组到底要定义多长呢？当指定类型的数组长度小于集合的size(),那么该方法内部会创建一个新的数组。长度为集合的size.当指定类型的数组长度大于集合的size(),就不会新创建数组，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。2.为什么要将集合变数组？为了限定对元素的操作，不需要进行增删了。*/String[] arr = al.toArray(new String[al.size()]);System.out.println(Arrays.toString(arr));}}

/*高级for循环：格式：for (数据类型 变量名 ：被遍历的集合(collection)或者数组){}对集合进行遍历。只能获取集合元素，但是不能对集合进行操作。迭代器除了遍历，还可以在遍历过程中对集合进行增删改查的动作。传统for和高级for有什么区别呢？高级for有一个局限性，必须要有被遍历的目标。建议在遍历数组的时候，还是希望用传统for，因为传统for可以定义角标。*/import java.util.*;class ForEachDemo {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");for (String s : al ) {System.out.println(s);}System.out.println(al);/*Iterator<String> it = al.iterator();while(it.hasNext()){System.out.println(it.next());}*/int[] arr = {3,4,1};for (int x = 0;x < arr.length ;x++ ) {System.out.println(arr[x]);}for (int i : arr ) {System.out.println(i);}HashMap<Integer,String> hm = new HashMap<Integer,String>();hm.put(1,"a");hm.put(2,"b");hm.put(3,"c");Set<Integer> keySet = hm.keySet();for (Integer i : keySet ) {System.out.println(i+"::"+hm.get(i));}//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();//for (Map.Entry<Integer,String> me : entrySet) {         for(Map.Entry<Integer,String> me : hm.entrySet()) {System.out.println(me.getKey()+"-----"+me.getValue()); }}}

/*JDK1.5版本出现的新特性。方法的可变参数。在使用时注意：可变参数一定要定义在参数列表最后面。*/class ParamMethodDemo {public static void main(String[] args) {/*可变参数：其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。*/show("haha",2,3,4,5,6);//show(2,3,4,5,6,4,5,45,9);//show();System.out.println("Hello World!");}public static void show(String a,int... arr) {System.out.println(arr.length);}}

/*静态导入：当类名重名时，需要指定具体的包名。当方法名相同时，指定具备所属的对象或者类。*/import java.util.*import static java.util.Arrays.*;//导入的是Arrays这个类中所有静态成员import static java.lang.System.*;//导入了System类中所有的静态成员class StaticImport {public static void main(String[] args) {out.println("hehe");System.out.println("Hello World!");}}

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------