day16 Java学习(List集合)

集合框架（去除ArrayList集合重复元素）

    

    public static ArrayList getSingle(ArrayList list) {
        ArrayList newlist=new ArrayList<>();      //创建新集合
        Iterator it=list.iterator();              //根据传入的集合获取迭代器
        while (it.hasNext()) {                    //遍历传入的集合
            Object object = (Object) it.next();   //记录每一个元素
            if (!newlist.contains(object)) {      //如果新集合中不包含传入集合的元素 
                newlist.add(object);              //将该元素添加
            }
        }
        return newlist;
    }

集合框架（去除ArrayList集合重复自定义对象元素）    

   注意：要在Person文件内重写equals方法

   contains方法判断是否包含，底层依赖的是equals方法。

//这是在Person重写的
public boolean equals(Object obj) {
         Person p=(Person) obj;
         return  this.name.equals(p.name) &&this.age==p.age;
             }

这是在Main方法内的
public static ArrayList getSingle(ArrayList list) {
        ArrayList newlist=new ArrayList<>();      //创建新集合
        Iterator it=list.iterator();              //根据传入的集合获取迭代器
        while (it.hasNext()) {                    //遍历传入的集合
            Object object = (Object) it.next();   //记录每一个元素
            if (!newlist.contains(object)) {      //如果新集合中不包含传入集合的元素 
                newlist.add(object);              //将该元素添加
            }
        }
        return newlist;
    }

集合框架（ LinkedList特有功能 )

  

        LinkedList list=new LinkedList();
        list.addFirst("d");   //addFirst()在集合第一个位置添加元素
        list.addLast("e");    //addLast()在集合尾部位置添加元素
        list.removeFirst();   //removeFirst()删除集合第一个元素
        list.removeLast();    //removeLast()删除集合最后一个元素
        System.out.println(list.get(2)); //get(index) 根据索引查找元素

集合框架（栈和队列数据结构）

   栈：  先进后出 。

   队列：先进先出。 

 集合框架（用LinkedList模拟栈数据结构的集合并测试）

     

public class Stack {
    private LinkedList  list=new LinkedList();
       
     //模拟进栈方法
    public void in(Object obj) {
        list.addLast(obj);
    }
     //模拟出栈方法
      public Object out() {
        return list.removeLast();
    }
      
     //模拟栈结构是否为空
      public boolean isEmpty() {
        return list.isEmpty();  
    }
}

//主方法
public static void main(String[] args) {
        // TODO 自动生成的方法存根

        Stack s = new Stack();        //创建栈结构
        s.in("a");                    //进栈
        s.in("b");
        s.in("c");
        while (!s.isEmpty()) {        //isEmpty()  判断栈结构是否为空
         System.out.println(s.out()); //弹栈 
        }
    }

集合框架（泛型 Generic)

   泛型的好处：
        * 提高安全性（将运行期的错误转换到编译期）
        * 省去强转的麻烦 
    
   泛型的基本使用：
        * <>中放到必须是引用数据类型。
   泛型使用注意事项：
        * 前后的泛型必须一致，或者后面的泛型可以省略不写（1.7的新特性 ：菱形泛型）
        
      

public static void main(String[] args) { 
        ArrayList<Person> list =new ArrayList<>();    //前后的泛型<>必须一致，或者后面的泛型可以省略不写（1.7的新特性 ：菱形泛型）
        list.add(new Person("张三",14));
        list.add(new Person("李四",14));
        list.add(new Person("王五",14));
        
        Iterator<Person> it= list.iterator();
           
        while (it.hasNext()) {
          //Person p = (Person) it.next(); 
            Person p = it.next();                      //向下转型 （省略了强转）
            
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }

    

集合框架（泛型方法)

    概述： 把泛型定义在方法上。
    格式： public <泛型类型> 返回类型 方法名 （ 泛型类型 变量名）

public class Too<S> {
    public void show(S s) {            //方法泛型最好与类的泛型一致
        System.out.println(s);
    }

    public <T> void print(T t) {       //如果不一致，需要在方法上声明该泛型
        System.out.println(t);
    }

    public static <W> void name(W w) { // 静态方法必须声明自己的泛型(最好与类的泛型不一致)
        System.out.println(w);
    }
}

 集合框架（泛型高级之通配符）

  泛型通配符 < ？>

     * 任意类型（如果没有明确，那么就是Object及任意的Java类。）

   ？extends E

     * 向下限定，E及其子类

集合框架（Foreach的概述和使用）
   
   概述： 简化数组和Collection集合的遍历
   格式： 
        for （元素数据类型  变量  ： 数组或者Collection集合）{

          使用变量即可，该变量就是元素
        }

    public static void main(String[] args) {
        // 数组遍历
        int[] arr = { 11, 22, 33, 44, 55, 66 };
        for (int i : arr) {
            System.out.println(i);
        }
        
        //Collection集合遍历
         Collection <Person>list=new ArrayList<>();
         list.add(new Person("张三",14));
         list.add(new Person("李四",14));
         list.add(new Person("王五",14));
        for (Person p : list) {
               System.out.println(p.getName()+"..."+p.getAge());
        }
    }

}

集合框架（迭代删除）

  * for循环删除（但是索引必须要 减减（--）防止重复删除元素出现）

    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");    
   
        //普通for循环删除
       for (int i = 0; i < list.size(); i++) {
          if ("b".equals(list.get(i))) {
              list.remove(i--);                //索引要--，防止有重复的被删元素
           } 
        }
        System.out.println(list);
    }

  * 迭代器删除

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();    
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");

        //迭代器删除
        Iterator<String> it=list.iterator();
        while (it.hasNext()) {
            if ("b".equals(it.next())) {
                it.remove();
            }
            
        }
        System.out.println(list);
    }

集合框架（可变参数）
   概述： 定义方法不知道该定义多少个参数。
   格式： 修饰符  返回值类型  方法名  （数据类型 ... 变量名）{}
   注意事项：
          * 这里的变量其实是一个数组
          * 如果一个方法有可变参数，并且有多个参数，那么可变参数肯定是最后一个。

集合框架（Arrays工具类的asList()方法的使用）

         /*
         * 数组转集合，数组必须是引用数据类型
         * 不能增加或减少元素，但是可以使用集合中的其他
         */
        
        //Integer数组转换成集合
        // int [] arr1 = {11,22,33,44,55};         //基本数据类型数组转换成集合,会将整个数组当作一个对象转换。
        Integer[] arr1 = { 11, 22, 33, 44, 55 };  
        List<Integer> list1 = Arrays.asList(arr1);
        
        
        //字符数组转集合
        String[] arr = { "a", "b", "c" }; 
        List<String> list = Arrays.asList(arr);

     ArrayList<String> list=new ArrayList<>();
     list.add("a");
     list.add("b");
     list.add("c");
     String [] arr= list.toArray(new String[0]); //当集合转换数组时，数组长度小于等于集合size时，转换后的数组长度等于集合size。