2017

0 使用List的任何子类存储字符串或者存储自定义对象并遍历
1 ArrayList
(1)ArrayList 存储字符串并遍历
  ArraList aray =new ArrayList();
  //创建元素对象，并添加元素
  array.add("hello");
  array.add("world");
  array.add("java");
  //遍历
  Iterator it = array.iterator();
  while(it.hasNext()){
        String s = (String)it.next();
        System.out.println(s);
  }

(2) ArrayList存储自定义对象并遍历
    //创建集合对象
    ArrayList array = new ArrrayList();
    //创建学生对象
    Student s1 = new Student("武松",30);
    Student s2 = new Student("林冲",40);
    Student s3 = new Student("鲁智深",35);
    Student s4 = new Student("杨志",32);
    //添加元素
    array.add(s1);
    array.add(s2);
    array.add(s3);
    array.add(s4);
    //遍历
    Iterator it = array.iterator();
    while(it.hasNext()){
        Student s = (Student)it.next();
        System.out.println(s.getName()+"---"+s.getAge());
      }

2 Vector 的特有功能
     A：添加功能                                        被这些替代(简化书写)
        public void addElement(Object obj)     --- add()
     B:获取功能
        public Object elementAt(int index)        --- get()
        public Enumeration  elements()            --- Iterator iterator()
             boolean hasMoreElements()                hasNext()
             Object nextElements                              next()

jdk升级的原因：
  A:安全 B:效率 D:简化书写
--------------------------------------------------------
     // 创建集合对象
     Vector v = new Vector();
     // 添加功能
     v.addElement("hello");
     v.addElement("world");
     v.addElement("java");
     //遍历
     for(int x = 0;x < v.size();x++){
         String s = (String)v.elementAt(x);
         System.out.println(s); 
  }
     Enumeratiron en = v.elements();//返回的是实现类的对象
     while(en.hasMoreElements()){
          String s =(String)en.nextElement();
          System.out.println(s);
   }
   //输出 hello
          world 
          java
          hello
          world 
          java

3 LinkedList 的特有功能
  A:添加功能
     public void addFirst(Object e)
     public void addLast(Object e)
  B:获取功能
     public Object getFirst()
     public Object getLast()
  C:删除功能
     public Object removeFirst()  //删除并返回
     public Object removeLast()
---------------------------------------
  LinkedList link =new LinkedList();
  //创建元素对象，并添加元素
  link.add("hello");
  link.add("world");
  link.add("java");
  link.addFirst("javaee");
  System.out.println("link:"+link);
  //输出link:[javaee,hello,world,java]

4 练习
(1)：ArrayList 去除集合中字符串的重复值
    //创建集合对象
    ArrayList array = new ArrrayList();
    //添加多个字符串元素
    array.add("hello");
    array.add("world");
    array.add("java");
    array.add("hello");
    array.add("world");
    array.add("java");
    array.add("hello");
    array.add("world");
    array.add("java");
    //创建新集合
    ArrayList newArray = new ArrrayList();
    //遍历旧数组，获取得到每一个元素
    Iterator it = array.iterator();
    while(it.hasNext()){
           String s = (String)it.next();
    //拿这个元素到新集合去找，看有没有
    if(!newArray.contains(s)){
           newArray.add(s);
      }
   }
     //遍历新集合
     for(int x = 0;x<newArray.size();x++){
           String s = (String) newArray.get(x);
           System.out.println(s);
    }


(2)ArrayList 去除集合中字符串的重复值---但不能创建新的集合，就在以前的集合上做
    //创建集合对象
    ArrayList array = new ArrrayList();
    //添加多个字符串元素
    array.add("hello");
    array.add("world");
    array.add("java");
    array.add("hello");
    array.add("world");
    array.add("java");
    array.add("hello");
    array.add("world");
    array.add("java");
    //用选择排序思想，那前面的和后面的相比较，如果有，就删除
    for(int x = 0;x<array.size()-1:x++){
                for(int y = x+1;y<array.size();y++){
                     if(array.get(x).equals(array.get(y))){
                            array.remove(y);
         }
    }
}
    Iterator it = array.iterator();
    while(it.hasNext()){
        Student s = (Student)it.next();
        System.out.println(s);
      }

(3)ArrayList 去除集合中自定义对象的重复值(对象的成员变量值都相同)
    //创建集合对象
    ArrayList array = new ArrrayList();
    //创建学生对象
    Student s1 = new Student("武松",30);
    Student s2 = new Student("林冲",40);
    Student s3 = new Student("鲁智深",35);
    Student s4 = new Student("杨志",32);
    Student s5 = new Student("杨志",32);
    //添加元素
    array.add(s1);
    array.add(s2);
    array.add(s3);
    array.add(s4);
    array.add(s5);
   //创建新集合
    ArrayList newArray = new ArrrayList();
    //遍历旧数组，获取得到每一个元素
    Iterator it = array.iterator();
    while(it.hasNext()){
       Student s = (Student)it.next();
    //拿这个元素到新集合去找，看有没有
    if(!newArray.contains(s)){
           newArray.add(s);
      }
   }
     //遍历新集合
     for(int x = 0;x<newArray.size();x++){
           String s = (String) newArray.get(x);
           System.out.println(s);
    }
   
-----------------------------------------------
   但是这样会出问题，通过简单分析，知道了问题出现在判断语句上
   contains()方法的底层依赖的是equals()方法
   而自定义的学生类中没有equals()方法，这个时候，默认使用的是他父类Object的equals()方法
   Object类的equals()默认比较的地址值，所以，它们都进去了，因为new的东西，地址值不同
    所以，比较成员变量的值，重写equals ，用自动生成就行了
-----------------------------------------------
***(4) 用LinkedList模拟栈数据结构的集合，并测试
   题目的意思是：
       自定定义一个结合类，在这个集合类内部可以使用LinkedList模拟
    A：linkedList的特点添加功能addFirst()
    B: 栈的特点先进后出
    
  public class MyStack{
       private LinkedList link;
       public MyStack(){
           link = new LinkedList();  
        }
       public void add(Object obj){
           link.addFirst(obj);
       }
       public Object get(){
          // return link.getFirst();
             return link.removeFirst();
     }
       //判断是否为空
       public boolean isEmpty(){
            return link.isEmpty();
       }
 }
  //测试
   MyStack ms = new MyStack();
  //添加元素
   ms.add("hello");
   ms.add("world");
   ms.add("java");
   while(!ms.isEmpty()){
        System.out.println(ms.get());
 }
  //输出 java 
          world
          hello

5 泛型
泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊类型。参数化类型，把类型当做参数一样的传递。
格式：
   <数据类型>
***此处的数据类型只能是引用类型。8种基本数据类型不行，但可以用包装类。
好处：
   A:把运行时期的问题提前到了编译期间
   B:避免了强制类型转换

   C:优化了程序设计，解决了黄色警告线

 泛型在哪些地方使用呢？
   看API,如果类，接口，抽象类后面跟着有<E>就说明要使用泛型，一般来说在集合中使用
--------------------------------------------------
  ArraList<String> aray =new ArrayList<String>();
  //创建元素对象，并添加元素
  array.add("hello");
  array.add("world");
  array.add("java");
  //遍历
  Iterator<String> it = array.iterator();
  while(it.hasNext()){
        String s = it.next();
        System.out.println(s);
  }
---------------------------------------------------
    //创建集合对象
    ArrayList<Student> array = new ArrrayList<Student>();
    //创建学生对象
    Student s1 = new Student("武松",30);
    Student s2 = new Student("林冲",40);
    Student s3 = new Student("鲁智深",35);
    Student s4 = new Student("杨志",32);
    //添加元素
    array.add(s1);
    array.add(s2);
    array.add(s3);
    array.add(s4);
    //遍历
    Iterator<Student> it = array.iterator();
    while(it.hasNext()){
        Student s = it.next();
        System.out.println(s.getName()+"---"+s.getAge());
      }

6 泛型
  早期的时候，我们使用Object来代表任意的类型。
  向上转型是没有任何问题的，但是在向下转型的时候其实隐藏了类型转换的问题。
  也就是说这样的程序其实并不是安全的，所以java在jdk5后引入了泛型，提高了程序的安全性

泛型类
   把泛型定义在类上
   格式：public class 类名<泛型类型1,..>
   注意 泛型类型必须是引用类型
泛型方法
   把泛型定义在方法上
   格式：public<泛型类型>返回类型 方法名(泛型类型)
泛型接口
   把泛型定义在接口上
   格式：public interface 接口名<泛型类型1,...>

(1)泛型类
   public class ObjectTool<T>{
       private T obj;
       public T getObj(){
          return obj;
      }
       public void setObj(){
          this.obj = obj;
    }
-------------------------------------------
   //测试
   ObjectTool ot = new ObjectTool();
   ot.setObj(new String("风清扬"));
   String s = (String)ot.getObj();
   System.out.println(s);
   //风清扬
   ot.setObj(new Integer(30));
   Integer i = (Integer)ot.getObj();
   System.out.println(i);
   //30
   ot.setObj(new String("风清"));
   Integer i = (Integer)ot.getObj();
   System.out.println(s);
   //报错
--------------------------------------------
   //应该这么使用
   ObjectTool<String> ot = new ObjectTool<String>();
   //ot.setObj(new Integer(30));//这个时候编译期间就会过不去
   ot.setObj(new String("风清扬"));
   String s =ot.getObj();   //不用转型
   System.out.println(s);

   ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
   //ot.setObj(new String("风清扬"));//这个时候编译期间就会过不去
   ot.setObj(new Integer(30));
   Integer i = ot2.getObj();
   System.out.println(i);

(2)泛型方法
  public class ObjectTool(
       public <T> void show(T t){
              System.out.println(t);
  }
  ObjectTool ot = new ObjectTool();
  ot.show("hello");
  ot.show(100);
  ot.show(true);
  //输出：hello 
          100
          true

(3)泛型接口
   public interface inter<T>{
       public abstract void show(T t);
   }
   //实现类在实现接口的时候
   //第一种情况：已经知道是什么类型的了 
   //第二种情况：还不知道是什么类型的
  
   //第一种情况测试
   public class InterImpl implements Inter<String>{
    @Override
    public void show(String t){
       System.out.println(t);

   }

}

   Inter<String> i = new InterImpl();
   i.show("hello");

   //第二种情况测试
   public class InterImpl<T> implements Inter<T>{
    @Override
    public void show(T t){
       System.out.println(t);
   }
   Inter<String> i = new InterIml<String>();
   i.show("hello");
   Inter<Integer> i = new InterIml<Integer>(); 
   i.show(100);
   //输出： hello  100
   //但又回到泛型类当中了。。。。   

7 泛型高级(通配符)
(1)?:任意类型，如果没有明确，那么就是Object以及任意的java类了
   //泛型如果明确的写的时候，前后必须一致
   Collection<Object> c1 = new ArrayList<Object>();
   //Collection<Object> c2 = new ArrayList<Animal>();  //报错
   //Collection<Object> c3 = new ArrayList<Dog>();     //报错
   //Collection<Object> c4 = new ArrayList<Cat>();     //报错
   //？表示任意里的类型都是可以的
   Collection<?> c5 = new ArrayList<Object>();
   Collection<?> c6 = new ArrayList<Animal>();  //不会报错
   Collection<?> c7 = new ArrayList<Dog>();     //不会报错
   Collection<?> c8 = new ArrayList<Cat>();     //不会报错

(2)? extends E:向下限定，E及其子类
  Collection<? extends Animal> c9 = new ArrayList<Object>();  //报错
  Collection<? extends Animal> c10 = new ArrayList<Animal>();//不会报错
  Collection<? extends Animal> c11 = new ArrayList<Dog>(); //不会报错
  Collection<? extends Animal> c12 = new ArrayList<Cat>(); //不会报错

    ? super E: 向上限定 ，E及其父类
  Collection<? super Animal> c9 = new ArrayList<Object>();  //不会报错
  Collection<? super Animal> c10 = new ArrayList<Animal>();//不会报错
  Collection<? super Animal> c11 = new ArrayList<Dog>(); //报错
  Collection<? super Animal> c12 = new ArrayList<Cat>(); //报错

8 JDK5新特性：自动拆装箱,泛型,增加for,静态导入,可变参数,枚举
(1) 增加for：是for循环的一种
    for(元素数据类型 变量：数组或者Collection集合){
                  使用变量即可，该变量就是元素
         }
     int[] arr = {1,2,3,4,5}
     for(int x:arr){
           System.out.println(x);
     }
     //输出  1  2 3 4 5

  好处： 简化了数据和集合的遍历
  弊端： 增加for的目标不能为null
----------------------------------------------
  ArrayList<String> array = new ArrayList<String>();
  array.add("hello");
  array.add("world");
  array.add("java");
  //遍历集合
  //迭代器
  Iterator<String> it = array.iterator();
  while(it.hasNext()){
        String s = it.next();
        System.out.println(s);
  }
  //普通for 
  for(int x = 0;x<arry.size();x++){
           String s = array.get(x);      
           Sytem.out.println(s);
  }
  //增加for
  for(String s : array){
     System.out.println(s);
  }
  // hello  
     world 
     java
---------------------------------------------------
    //创建集合对象
    ArrayList<Student> array = new ArrrayList<Student>();
    //创建学生对象
    Student s1 = new Student("武松",30);
    Student s2 = new Student("林冲",40);
    Student s3 = new Student("鲁智深",35);
    Student s4 = new Student("杨志",32);
    //添加元素
    array.add(s1);
    array.add(s2);
    array.add(s3);
    array.add(s4);
    //遍历
    //迭代器
    Iterator<Student> it = array.iterator();
    while(it.hasNext()){
        Student s = it.next();
        System.out.println(s.getName()+"---"+s.getAge());
      }
    //普通for
    for(int x =0;x<array.size();x++){
         Student s =array.get(x);
         System.out.println(s.getName()+"---"+s.getAge());
       }
    //增加for 
    for(Student s :array){
        System.out.println(s.getName()+"---"+s.getAge());
    }

(2)静态导入
   静态导入：可以直接导入方法的级别
     注意事项：
          A：方法必须是静态的
          B:如果有多个同名的静态方法，容易不知道使用谁，这个时候使用需要加别称。
-----------------由此可见，意义不大，但要看得懂就行-------------

   System.out.println(java.lang.Math.abs(-100));
   System.out.println(java.lang.Math.pow(2,3)); //2的3次方8

   //太复杂，我们就引入到import

   import java.lang.Math
   System.out.println(Math.abs(-100));
   System.out.println(Math.pow(2,3)); 

   //太复杂，有更简单的

   import java.lang.Math.abs
   import java.lang.Math.pow
   System.out.println(abs(-100));
   System.out.println(pow(2,3)); 

(3)可变参数
    可变参数：定义方法的时候不知道该定义多少个参数
    格式：
       修饰符 返回值类型 方法名(数据类型...变量名){
      }
    注意：这里的变量其实是一个数组
     int a = 30;
     int b = 30;
     result =sum (a,b);
     System.out.println(result);
    
     int c = 30;
     result =sum (a,b,c);
     System.out.println(result);

     public static int sum(int...a) {
              int s = 0;
              for(int x : a){
                  s+=x;
             }
            return s;
       }
 
      //输出： 60 
                     90

9 Arrays 工具类的 asList() 方法的使用
  public static <T> List<T> asList(T...a):把数组转成集合

  注意：虽然可以把数组转成集合，但是集合的长度不能改变，其本质是数组。

  //String[] strArray ={"hello","world","java"};
  //List<String> list = Arrays.asList(strArray);
  List<String> list = Arrays.asList("hello","world","java");
   
  for(String s: list){
      System.out.println(s);
  }
  //输出：hello  
               world
                java
  //list.add("javaee");//报错
  //list.remove(1);    //报错
  list.set(1,"javaee");//不报错

10 练习
(1)集合的嵌套遍历
   需求：我们班有学生，每个学生是一个对象，所以我们可以使用一个集合表示我们班级的学生， ArrayList<Student>
          但是还有其他的班级，所以其他班级也有一个ArrayList<Student>
          于是：ArrayList<ArrayList<Student>>
    //创建大集合
    ArrayList<ArrayList<Student>> bigArrayList =new ArrayList<ArrayList<Student>>();
   //创建第一个班级的学生集合
    ArrayList<Student> firstArrayList = new ArrayList<Student>();
    Student s1 = new Student("武松",30);
    Student s2 = new Student("林冲",40);
    Student s3 = new Student("鲁智深",35);
    //学生1进班
    firstArrayList.add(s1);
    firstArrayList.add(s2);
    firstArrayList.add(s3);
    //把第一个班级存储到学生系统中
    bigArrayList.add(firstArrayList);

    //创建第二个班级的学生集合
    ArrayList<Student> secondArrayList = new ArrayList<Student>();
    Student s4 = new Student("贾宝玉",22);
    Student s5 = new Student("林黛玉",21);
    Student s6 = new Student("薛宝钗",20);
    //学生2进班
    secondArrayList.add(s4);
    secondArrayList.add(s5);
    secondArrayList.add(s6);
    //把第二个班级存储到学生系统中
    bigArrayList.add(secondArrayList);

    //遍历集合
     for(ArrayList<Student> arry: bigArrayList){
           for(Student s : array){
                System.out.println(s.getName()+"---"+s.getAge());
         }
 }

(2)产生10个1-20之间的随机数，要求随机数不能重复
    用数组实现，但是数组的长度是固定的，长度不好确定
    所以我们使用集合实现

    //创建产生随机数的对象
    Random r = new Random();
    //创建一个存储随机的集合
    ArrayList<Integer> array = new ArrayList<Integer>();
    //定义一个统计变量，从0开始
    int count = 0;
    //判断统计遍历是否小于10
    while(count < 10){
          //先产生一个随机数
          int number =r.nextInt(20)+1;
          //判断该随机数在集合中是否存在
          if(!array.contains(number)){
                //如果不存在，就添加，统计++
                 array.add(number);
                 count++;
            }
     }
     //遍历集合
     for(Integer i:array){
          System.out.println(i);
    }

(3)键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
    //创建键盘录入数据对象
    Scanner sc = new Scanner(System.in);
    //键盘录入多个数据，我们不知道多少个，所以用集合储存
    ArrayList<Integer> array = new ArrayList<Integer>();
    //以0结束，这个简单，只要键盘录入的数据是0，就不再录入了
    while(true){
           System.out.println("请输入：");
           int number = sc. nextInt();
           if(number!=0){
              array.add(number);
       } else{
            break;
         }
 }
     //把集合转成数组
      Integer[] i = new Integer[array.size()]
      array.toArray(i);
      //对数组排序
      Arrays.sort(i);
      //获取该数组中的最大索引的值
      System.out.println(i[i.length-1]);