集合部分：集合遍历的三种方式，集合中常见的方法，集合的正序遍历，集合的逆序遍历，list，set，map，内部比较器comparable与外部比较器comparator的区别，数组转集合与集合转数组

 集合：

package com.bjsxt.collection;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

public class TestCollection {

        /**

        * 增 :add(Object obj )  addAll(Collection cl )

        * 删 :clear() ,remove(Object o)

        * 改 :

        * 查 : iterator() ,size()

        * 判断 :contains(Object o) isEmpty()*/

        public static void main(String[] args ) {

                //(1) 创建集合对象 , 集合中存储的是对象的内存地址

                Collection col=new ArrayList ();

               System. out .println( " 集合中元素的个数 :" + col .size()+ "\t 集合是否为空 :" + col .isEmpty());

               

                /**(1) 使用 add 方法在集合添加对象 */

                col .add( "hello" ) ; // 进行了向上类型转换相当于 Object obj = new String("hello");

                col .add( new Integer(10)) ;   // 相当于 Object obj =new Integer(10);

                col .add(120) ;   //jdk1.5 时，自动装箱， Integer i=120;

               Date d = new Date();

                col .add( d ) ;   // 相当于 Object obj =new Date();

                col .add( "world" ) ;

               

               System. out .println( " 集合中元素的个数 :" + col .size()+ "\t 集合是否为空 :" + col .isEmpty());

                /**(2) 删除 */

                col .remove(120);

               System. out .println( col ); // 重写了 toString 方法

                col .remove( d );

               

                //col.clear();

               System. out .println( col .size());

               

                /**(3) 判断指定对象在集合中是否存在 */

               System. out .println( col .contains( new Integer(10)));

               System. out .println( col .contains(10));

               

                /**(4) 遍历集合 */

               System. out .println( "\n 加强 for 循环遍历集合 " );

                for (Object obj : col ) {

                       System. out .println( obj );

               }

               System. out .println( "\n 使用迭代器遍历集合 " );

                Iterator ite = col . iterator ();

                while ( ite .hasNext()){

                        //Object o=ite.next();

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

               }

               

               System. out .println( "\n 迭代器 " );

               

                for ( Iterator it = col . iterator (); it .hasNext();){

                       System. out .println( it .next());
               }
       }
}

ArrayList的原理:

当调用无参构造方法创建对象时，实际上是创建了一个初始容量为10的Object类型的数组

ArrayList的底层数据结构是数组

16.2.2List接口

位于java.util包中

所有与索引有关的方法都是List接口特有的方法

          有序，不唯一

   -->ArrayList   :数组

   -->LinkedList  :链表

   -->Vector   :数组

package com.bjsxt.collection;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Vector;

public class TestList {

        public static void main(String[] args ) {

                List list = new LinkedList ();

                List list2 = new ArrayList ();

                List list3 = new Vector ();

               

                // 添加元素

                list .add( "hello" ) ;

                list .add( "world" ) ;

                list .add( "hello" ) ;

                list .add( "java" ) ;

                list .add(0, "html" ) ;

               System. out .println( list );

                list .remove(3);

               System. out .println( list );

               System. out .println( list .get(3));

               

                // 遍历 List 集合的三种方式

               System. out .println( "\n 加强 for" );

                for (Object obj : list ) {

                       System. out .println( obj );

               }

               System. out .println( "\n 迭代器 iterator()" );

                for ( Iterator ite = list .iterator(); ite .hasNext();){

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

               }

               System. out .println( "\n 普通 for" );

                for ( int i = 0; i < list .size(); i ++) {

                       System. out .println( list.get(i) );
               }
       }
}

Iterator 接口与 Iterable 接口之间的关系

在Iterable接口中定义了一个方法，iterator()，该方法的返回值类型为Iterator接口类型。

ListIterator接口是Iterator接口的扩展（子接口）对Iterator中的方法进行了扩展

package com.bjsxt.collection;

import java.util.LinkedList;

import java.util.ListIterator ;

public class TestLinkedList3 {

        public static void main(String[] args ) {

       

                LinkedList list = new LinkedList ();

                list .add( "hello" ) ;

                list .addFirst( "word" ) ;

                list .addFirst( "java" ) ;

                list .addLast( "html" ) ;

               System. out .println( list );

                /*System.out.println(list.getFirst());//java

               System.out.println(list.getLast());// html

               System.out.println(list.removeFirst());//java

               System.out.println(list.removeLast());// html

               System.out.println(list);*/

               System. out .println( " 正向遍历 \n" );

                ListIterator ite=list.listIterator();

               

                while ( ite .hasNext()){

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

               }

               System. out .println( " 逆向遍历 \n" );

                while ( ite .hasPrevious()){

                       System. out .println( ite .previous());
               }
       }
}

集合遍历的三种形式

集合的正序遍历

集合的逆序遍历

Set接口

  Set接口的特点：唯一，无序

  -->HashSet   如果有重复元素，将添加不成功

package com.bjsxt.set;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class TestSet {

        public static void main(String[] args ) {

                // 在创建集合对象时，就明确了集合中只能存储 String 类型的对象

                Set<String> set=new HashSet<String>();

                /**(1) 向集合添加元素 */

               System. out .println( set . add ( "hello" ));

               System. out .println( set .add( "world" ));

               System. out .println( set .add( "java" ));

               System. out .println( set .add( "world" )); // 没添加进去

               System. out .println( " 集合是否为空： " + set .isEmpty()+ "\t 集合中元素的个数 :" + set .size());

               System. out .println( set );

               System. out .println( "java 在集合中是否存在 :" + set .contains( "java" ));

                // 根据对象删除元素

                set .remove( "java" );

                //set.clear();

               System. out .println( " 使用加强 for 循环 \n" );

                for (String string : set ) {

                       System. out .println( string );

               }

       

               System. out .println( " 使用迭代器 \n" );

                for (Iterator<String> ite = set .iterator(); ite .hasNext();){

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

               }

               

       }

}

HashSet的底层数据结构为哈希表

  HashSet存储自定义对象时，要求 必须重写hashCode()及equals()方法 ，用于去掉重复元素

  在调用add的添加方法时，自动调用hashCode()方法，用于计算每个对象的hash码值，根据y=k(x)的函数计算对象的存储位置，  x为哈希码值  y为存储位置,,如果该位置没有对象，则将对象添加到该位置，如果该位置上有对象，则调用equals()方法，比较对象的内容是否相同，如果内容，则不添加，如果内容不相同，则继续添加到该位置上。

Set接口

  -->HashSet

            --->LinkedHashSet   有序，唯一    链表+哈希表

LinkedHashSet的代码

package com.bjsxt.linkedhashset;

import java.util.Iterator;

import java.util.LinkedHashSet;

public class TestLinkedHashSet {

       public static void main(String[] args) {

               //在创建集合对象时，就明确了集合所存储对象的类型

               LinkedHashSet<String> col=new LinkedHashSet<String>();

               

               /**向集合中添加元素*/

               col.add("hello");

               col.add("java");

               col.add("world");

               col.add("hello");

               

               System.out.println("集合中元素的个数："+col.size());

               System.out.println(col);

               

               //col.clear();

               col.remove("java");

               System.out.println(col);

               System.out.println("world在集合中是否存在:"+col.contains("world"));

               //遍历集合

               System.out.println("\n使用加强for");

               for (String str : col) {

                       System.out.println(str);

               }

               System.out.println("\n使用迭代器:");

               for(Iterator<String> ite=col.iterator();ite.hasNext();){

                       System.out.println(ite.next());
               }
       }
}

-->TreeSet    二叉树 ，红黑树

    -->唯一，升序

TreeSet的使用

package com.bjsxt.linkedhashset;

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

public class TestTreeSet {

       public static void main(String[] args) {

               //创建TreeSet集合对象，同时明确了集合中所存储的对象的类型，String

               TreeSet<String> ts=new TreeSet<String>();

               ts.add("banana");

               ts.add("apple");

               ts.add("grape");

               ts.add("apple");

               

               System.out.println("集合中元素的个数:"+ts.size());

               System.out.println(ts);

               

               //遍历

               for (String str : ts) {

                       System.out.println(str);

               }

               System.out.println("\n");

               

               

               /**希望在存储String时，按照String的长度进行升序*/

               //接口new实现类

               Comparator<String> com=new LengthCom();

               

               TreeSet<String> ts2=new TreeSet<String>(com);

               ts2.add("banana");

               ts2.add("apple");

               ts2.add("grape");

               ts2.add("apple");

               System.out.println(ts2);

               for (Iterator<String> ite=ts2.iterator();ite.hasNext();) {

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

               }

       }

}

class LengthCom implements Comparator<String>{

       @Override

       public int compare(String o1, String o2) {
               return o1.length()-o2.length();
       }
}

Comparable与Comparator接口

这两个接口都是具备比较大小的能力

Comparable内部比较器  :由需要比较的类(Person)去实现

public class Person implements Comparable<Person>{

           @Override

       public int compareTo(Person o) {

               

               //return this.name.compareTo(o.getName());

               //return this.name.length()-o.getName().length();

               return this.age-o.getAge();

       }

}

Comparator外部比较器   :新定义一个类去实现该接口  ，该类与需要比较的对象Person无关，只是一个比较规则

public class AgeCom implements Comparator<Person> {

       @Override

       public int compare(Person o1, Person o2) {

               

               return o1.getAge()-o2.getAge();

       }

}

Set接口

    -->HashSet  (哈希表) 无序，唯一

             -->LinkedHashSet(链表+哈希表)  有序，唯一

               与哈希有关的，存储自定义对象时，要求必须重写hashCode()及equals(Object obj)方法

    -->TreeSet   (二叉树)  有序，唯一

               实现比较规则  (Comparable接口,Comparator接口)

Map接口

   -->HashMap  (哈希表)  key是无序，唯一， value不唯一， （无序）

Map接口

   -->HashMap  (哈希表)  key是无序，唯一， value不唯一， （无序）

  HashMap的使用

package com.bjsxt.map;

import java.util.Set;
import java.util.TreeMap;

public class TestTreeMap {
        public static void main(String[] args) {
                TreeMap<String,Integer> tm=new TreeMap<String,Integer>(); 
                tm.put("tiger", 110);
                tm.put("cat", 112);
                tm.put("dog", 110);
                tm.put("dog", 1104);
                
                System.out.println(tm.size());
                System.out.println(tm);
                
                /**遍历treeMap集合*/
                Set<String> keys=tm.keySet();
                for (String k : keys) {
                        System.out.println(k+"-->"+tm.get(k));
                }
                
        }
}

Collections类
  (1)addAll(Collection<? super T>  col,T...t)
   (2)sort(List<T> list) 升序
   (2)sort(List<T> list,Comparator<T> com)
   (3)binarySearch(List<T> list,T key)
  (3) binarySearch(List<T> list,T key, Comparator<T> com)
  (4)reverse(List<T> list)  逆
  (5)shuffle(List<T> lit)  随机

package com.bjsxt.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TestCollections {
        public static void main(String[] args) {
                //创建了一个集合对象，数据类型明确，只能是String
                List<String> col=new ArrayList<String>();	
                /**将N多个对象，一性次添加到集合中*/
                Collections.addAll(col, "hello","world","java","sql","hello");
                System.out.println(col.size());
                System.out.println(col);
                /**对集合进行排序*/
                //Collections.sort(col);  //字母升序
                Comparator<String> com=new ComLength();
                Collections.sort(col, com);  //可以自己定义比较规则
                System.out.println(col);
                /**使用二分搜索进行查找元素*/
                System.out.println(Collections.binarySearch(col, "world"));  //4
                System.out.println(Collections.binarySearch(col, "java",com));//2
                System.out.println(col);
                /**逆向显示集合中的数据*/
                //Collections.reverse(col);   //逆序
                //System.out.println(col);
                /**随机顺序*/
                //Collections.shuffle(col);  //随机
                Collections.swap(col, 2, 3);
                change(col,2,3);
                System.out.println(col);
                
                
        }
        //手动编写的交换的方法
        public static void change(List<String> list,int i,int j){
                String temp=list.get(i);  //根据索引获取集合中的元素
                list.set(i, list.get(j));  //设置，将索引为i的位置上的元素设置为list.get(j)
                list.set(j, temp);
        }
}

/**如果该规则只使用一次，建议使用匿名内部类，如果该规则需要被使用N多次，建议单独写一个规则类*/
class ComLength implements Comparator<String>{
        @Override
        public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                return o1.length()-o2.length();
        }
}

将集合转数组

将数组转集合

package com.bjsxt.collections;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

public class TestArrayAndCollection {
        public static void main(String[] args) {
                Collection<String> set=new HashSet<String>();
                //集合中元素的个数为4个
                Collections.addAll(set, "hello","world","java","html","hello");
                System.out.println(set);
                /***集合转数组 */
                Object [] obj =set.toArray();
                System.out.println(Arrays.toString(obj));
                
                String [] str=new String[8];
                str=set.toArray(str);
                System.out.println(Arrays.toString(str));  //数组的length>集合的size(), 4个为null
                
                String [] str2=new String[3];
        
                str2=set.toArray(str2);  //因为在内存中重新开辟了数组的空间  重新以集合的长度为准new 一个数组
                
                System.out.println(Arrays.toString(str2));//数组的length<集合的size(),数组的length=集合的size()
                
                /**数组转集合*/
                int [] arra={123,43,43,455};
                List list=Arrays.asList(arra);
                System.out.println(list.size());
                System.out.println(list);  //[[I@6d06d69c]相当于二维数组
                /**将arra作为一个对象添加到了集合中，因为集合中只能存引用数据类型，集合中存的是对象*/
                
                Integer [] arrI={123,43,43,455};  //Integer类型的数组，中存储的4个Integer类型的对象
                List list2=Arrays.asList(arrI);
                System.out.println(list2.size());
                System.out.println(list2);
                
        }
}