day16集合

需求：

集合框架(去除ArrayList中重复字符串元素方式)(掌握)

    ArrayList去除集合中字符串的重复值(字符串的内容相同)
   * 思路：创建新集合方式

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

               System.out.println(list);
               ArrayList newList = getSingle(list);
               System.out.println(newList);
           }

           /*
           * 去除重复
           * 1,返回ArrayList
           * 2,参数列表ArrayList
           */
           public static ArrayList getSingle(ArrayList list) {
               ArrayList newList = new ArrayList();           //创建一个新集合
               Iterator it = list.iterator();                   //获取迭代器
               while(it.hasNext()) {                           //判断老集合中是否有元素
                   String temp = (String)it.next();           //将每一个元素临时记录住
                   if(!newList.contains(temp)) {               //如果新集合中不包含该元素
                       newList.add(temp);                       //将该元素添加到新集合中
                   }
               }
               return newList;                                   //将新集合返回
           }

集合框架(去除ArrayList中重复自定义对象元素)(掌握)

去除ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
重写equals()方法的

public class Person {
   private String name;
   private int age;
   public Person() {
       super();

   }
   public Person(String name, int age) {
       super();
       this.name = name;
       this.age = age;
   }
   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }
   public int getAge() {
       return age;
   }
   public void setAge(int age) {
       this.age = age;
   }
   @Override
   public String toString() {
       return "Person [name=" + name + ", age=" + age + "]";
   }
    @Override
   public boolean equals(Object obj) {
       Person p = (Person)obj;
       return this.name.equals(p.name) && this.age == p.age;
   }

}

因为Contains 方法中依赖的是equals方法，而在自定义的new 出来的每个地址都不一样，所有要复写equals方法。 getSingle方法代码同上

集合框架(LinkedList的特有功能)(掌握)
* B:LinkedList类特有功能
   * public void addFirst(E e)及addLast(E e)
   * public E getFirst()及getLast()
   * public E removeFirst()及public E removeLast()
   * public E get(int index);

###16.04_集合框架(栈和队列数据结构)(掌握)
* 栈先进后出
* 队列先进先出

根据此。我们可以做一个(用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) {
       //demo1();
       Stack s = new Stack();
       s.in("a");                               //进栈
       s.in("b");
       s.in("c");
       s.in("d");

       while(!s.isEmpty()) {                   //判断栈结构是否为空
           System.out.println(s.out());       //弹栈
       }
   }

结果：d
c
b
a

16.06_集合框架(泛型概述和基本使用)(掌握)
* A:泛型概述
* B:泛型好处
   * 提高安全性(将运行期的错误转换到编译期)
   * 省去强转的麻烦
* C:泛型基本使用
   * <>中放的必须是引用数据类型
* D:泛型使用注意事项
   * 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

ArrayList<Person> list = new ArrayList<Person>();
       list.add(new Person("张三", 23));
       list.add(new Person("李四", 24));

       Iterator<Person> it = list.iterator();
       while(it.hasNext()) {
           Person p = it.next();            //不用转型了
           System.out.println(p.getName() + "..." + p.getAge())

存储一个字符串并且遍历

    ArrayList<String> list = new ArrayList<>();           //创建集合对象
       list.add("a");
       list.add("b");
       list.add("c");
       list.add("d");

       Iterator<String> it = list.iterator();
       while(it.hasNext()) {
           System.out.println(it.next());
       }

###16.09_集合框架(泛型类的概述及使用)(了解)
* A:泛型类概述<T>
   * 把泛型定义在类上
* B:定义格式
   * public class 类名<泛型类型1,…>
* C:注意事项
   * 泛型类型必须是引用类型
* D:案例演示
   * 泛型类的使用

泛型类

public class Tool<Q> { //泛型方法
   private Q q;

   public Q getObj() {
       return q;
   }

   public void setObj(Q q) {
       this.q = q;
   }
    //泛型方法
   public<T> void show(T t) {               //方法泛型最好与类的泛型一致
       System.out.println(t);               //如果不一致,需要在方法上声明该泛型
   }

   public static<W> void print(W w) {       //静态方法必须声明自己的泛型
       System.out.println(w);
   }

}

实现

public static void main(String[] args) {
Tool<String> t = new Tool<>();
t.show(true); //打印出来就是show

Tool<Student> tt = new Tool<>(); //创建工具类对象
tt.setObj(new Student("张三",23));

Student s=tt.getQ();
System.out.println(s.getName()+" "+s.getAge());

集合框架(泛型接口的概述和使用)(了解)
* A:泛型接口概述
   * 把泛型定义在接口上
* B:定义格式
   * public interface 接口名<泛型类型>
* C:案例演示
   * 泛型接口的使用

定义一个泛型接口

public interface InfoDemo<T>{
public T getVar(); //都是抽象方法

}

一个类来实现它

public class InfoDemoImp implements InfoDemo<String> {
private String var;
public InfoDemoImp(String var){
this.setVar(var);
}
public void setVar(String var){
   this.var=var;
}
   @Override
   public String getVar() {
       // TODO Auto-generated method stub
       return this.var;
   }
}
   }

//找一个类来测试一下

    public static void main(String[] args) {
       // TODO Auto-generated method stub
InfoDemo w=new InfoDemoImp("liguo");
System.out.println("内容是"+w.getVar());
   }
结果是：liguo

集合框架(泛型高级之通配符)
* A:泛型通配符<?>
   * 任意类型，如果没有明确，那么就是Object以及任意的Java类了
* B:? extends E
   * 向下限定，E及其子类
* C:? super E
   * 向上限定，E及其父类

public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<Person> l1=new ArrayList<>();
l1.add(new Person("这哪个房",11));
l1.add(new Person("什么",12));
ArrayList<Student> l2=new ArrayList<>();
l2.add(new Student("liguo",15));
l2.add(new Student("liziqi",16));
l1.addAll(l2);
System.out.println(l1);
因为Person 是student 的父类，所以才可以添加

数组转换集合或者集合转数组

public static void demo1(){ //数组转换成集合
       Integer[] ar={5,6,52,96};
       List<Integer> l=Arrays.asList(ar); //包装类型
       System.out.println(l);
   }
   public static void demo2(){
       String[] arr={"liy","lifnag"};
       List<String> li = Arrays.asList(arr);
       System.out.println(li);
   }

   public static void demo3() {
       int[] ii = { 5, 6, 8, 74 };
       List<int[]> fo = Arrays.asList(ii); //看这个泛型类型就不一样了。
       System.out.println(fo);
   }

需求

    /**
   * * A:案例演示
   * 集合嵌套之ArrayList嵌套ArrayList
   * 案例:
   * 我们学科,学科又分为若个班级
   * 整个学科一个大集合
   * 若干个班级分为每一个小集合
   */
   public static void main(String[] args) {
       // TODO Auto-generated method stub
ArrayList<ArrayList<Person>> a=new ArrayList<>();
ArrayList<Person> first=new ArrayList<>();
first.add(new Person("杨幂", 30));
first.add(new Person("李冰冰", 33));
first.add(new Person("范冰冰", 20));
ArrayList<Person> second=new ArrayList<>();
second.add(new Person("黄晓明", 31));
second.add(new Person("赵薇", 33));
second.add(new Person("陈坤", 32));

//将班级添加到学科集合中
a.add(first);
a.add(second);
//遍历学科集合
for(ArrayList<Person> f:a){
   for(Person p:f){
       System.out.println(p);
   }
}

   }

集合框架(可变参数的概述和使用)(掌握)
* A:可变参数概述
   * 定义方法的时候不知道该定义多少个参数
* B:格式
   * 修饰符返回值类型方法名(数据类型… 变量名){}
* C:注意事项：
   * 这里的变量其实是一个数组
   * 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

集合框架(三种迭代的能否删除)(掌握)
* 普通for循环,可以删除,但是索引要--
* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
* 增强for循环不能删除

/**
   * * A:增强for概述
           * 简化数组和Collection集合的遍历
       * B:格式：
       *
               for(元素数据类型变量 : 数组或者Collection集合) {
                   使用变量即可，该变量就是元素
               }
       * C:案例演示
           * 数组，集合存储元素用增强for遍历
       * D:好处
           * 简化遍历
       增强for循环底层依赖的是迭代器(Iterator)
   */
   public static void main(String[] args) {
       // TODO Auto-generated method stub
       ArrayList<String> list = new ArrayList<>();
       list.add("a");
       list.add("b");
       list.add("b");
       list.add("c");
       list.add("d");
       //1,普通for循环删除,索引要--
   /*   for(int i=0;i<list.size();i++){
           if("b".equals(list.get(i))){
               list.remove(i--);      //这个可以的
           }
       }

   }*/
       //2,迭代器删除
               /*Iterator<String> it = list.iterator();
               while(it.hasNext()) {
                   if("b".equals(it.next())) {
                       //list.remove("b");                           //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
                       it.remove();   //这个可以的
                   }
               }*/


       //3,增强for循环,增强for循环不能删除,只能遍历
       for(String s:list){
           if("b".equals(s)){
               list.remove("b");
           }
       }

   System.out.println(list);

}