集合（二）

于 2016-04-28 15:08:10 发布
阅读量441 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013217071/article/details/51272419
版权

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

  • A:案例演示

    • 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

    • 思路：创建新集合方式

      /**
 *  A:案例演示
 * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
 * 思路：创建新集合方式
 */
public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add("a");
    list.add("a");
    list.add("b");
    list.add("b");
    list.add("b");
    list.add("c");
    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;                                 //将新集合返回
}

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

  • A:案例演示
    • 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
  • B:注意事项
    • 重写equals()方法
    • （因为contains方法和remove方法底层都依赖equals()方法，而equals()方法默认比较的是对象的地址值）
    • 重写后的equals():
@Override
    public boolean equals(Object obj) {
        Person p =(Person) obj;
        return this.name.equals(p.getName()) && this.age==p.getAge();   
    }

16.03_集合框架(LinkedList的特有功能)(掌握)

  • A: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_集合框架(栈和队列数据结构)(掌握)

  • 栈
    • 先进后出
  • 队列
    • 先进先出

16.05_集合框架(用LinkedList模拟栈数据结构的集合并测试)(掌握)

  • A:案例演示

    • 需求：请用LinkedList模拟栈数据结构的集合，并测试
    • 创建一个类将Linked中的方法封装
    • public class Stack {
    //创建LinkedList对象
    private LinkedList list = new LinkedList();

    public void in(Object obj) {
        list.addLast(obj);          //封装addLast()方法
    }

    public Object out() {
        return list.removeLast();   //封装removeLast()方法
    }

    public boolean isEmpty() {
        return list.isEmpty();      //封装isEmpty()方法
    }
}

16.06_集合框架(泛型概述和基本使用)(掌握)

  • A:泛型概述
  • 比如：Collection 标识了这个集合只能存储E类型或者E的子类型的元素
  • B:泛型好处
    • 提高安全性(将运行期的错误转换到编译期)
    • 省去强转的麻烦
public static void main(String[] args) {
        ArrayList alist =new ArrayList();
        alist.add("aaa");
        alist.add(true);
        alist.add(new Person("张三",23));

        Iterator itr = alist.iterator();
        while(itr.hasNext()){
            Person p = (Person) itr.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
//这里会报“java.lang.ClassCastException”错误，但编译时通过，运行时才报错误，所以这里可以将ArrayList加上泛型，限制类型，有类型不匹配时，便会在编译时报出。
  • C:泛型基本使用
    • <>中放的必须是引用数据类型
    • 注意：因为加上泛型后，可以存储该类型及该类型的子类型的元素，泛型要是写Object类型，没有意义，因为引用类型都是Object的子类型
  • D:泛型使用注意事项
    • 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
    • ArrayList<Object> list = new ArrayList<Person>();
      //错误，前后泛型类型要一致
      ArrayList<Person> list = new ArrayList<>();
      //正确，后面的泛型可以省略不写，1.7新特性，菱形泛型

16.07_集合框架(ArrayList存储字符串和自定义对象并遍历泛型版)(掌握)

  • A:案例演示
    • ArrayList存储字符串并遍历泛型版

16.08_集合框架(泛型的由来)(了解)

  • A:案例演示
    • 泛型的由来:通过Object转型问题引入
    • 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
//Tool类
public class Tool {
    private Object obj;
    public void setObj(Object obj){
        this.obj=obj;
    }
    public Object GetObj(){
        return obj;
    }
}
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Tool t =new Tool();                 //创建工具类对象
    t.setObj(new Student("张三",23)); //Object obj = new Student("张三",23);    
    Worker w = (Worker) t.GetObj();     //向下转型
    System.out.println(w);              //编译不报错，但是将Student对象强转为Worker对象，在运行时报错
}
    //使用泛型类解决

16.09_集合框架(泛型类的概述及使用)(了解)

  • A:泛型类概述
    • 把泛型定义在类上
  • B:定义格式
    • public class 类名<泛型类型1,…>
  • C:注意事项
    • 泛型类型必须是引用类型
  • D:案例演示
    • 泛型类的使用

Student、Worker类都继承自Person，Tool为工具类，将Tool定义为泛型类，会避免类型转换错误的情况。

//Tool类
public class Tool<Q> {
    private Q q;
    public void setQ(Q q){
        this.q=q;
    }
    public Q GetQ(){
        return q;
    }
}

public static void main(String[] args) {
    Tool<Student> t =new Tool<>();  //创建工具类对象
    t.setQ(new Student("张三",23));   //Object obj = new Student("张三",23);    
    Worker w = (Worker) t.GetQ();       //向下转型
    System.out.println(w);              //编译时就报错
}

16.10_集合 框架(泛型方法的概述和使用)(了解)

  • A:泛型方法概述
    • 把泛型定义在方法上
  • B:定义格式
    • public <泛型类型> 返回类型 方法名(泛型类型 变量名)
  • C:案例演示
    • 泛型方法的使用
//Tool类
public class Tool<Q> {
    private Q q;
    public void setQ(Q q){
        this.q=q;
    }
    public Q GetQ(){
        return q;
    }

    public void show1(Q q){     //方法的泛型最好要与类的泛型一致
        System.out.println(q);  
        //如果不一致，就要在方法上加上<泛型类型>，见下
    }
    public<T> void show2(T t){  
        //如果不一致，就要在方法上加上<泛型类型>
        System.out.println(t);  
    }
}
public static void main(String[] args) {
    Tool<Student> t =new Tool<>(); //创建工具类对象
    t.setQ(new Student("张三",23));   //Object obj = new Student("张三",23);    

    t.show1(new Student("李四",23));
    t.show2(true);
}

注意：静态方法必须声明自己的泛型，因为静态方法是随着类的加载而加载，但是Q只有在创建Tool对象时才有值。
public static<T> void print(T t){ //静态方法必须声明自己的泛型，T在调用静态方法时被赋值
System.out.println(t);
}

16.11_集合框架(泛型接口的概述和使用)(了解)

  • A:泛型接口概述
    • 把泛型定义在接口上
  • B:定义格式
    • public interface 接口名<泛型类型>
  • C:案例演示
    • 泛型接口的使用
    public class Demo3_generic {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }   
    public interface Inter<T>{
        public void show(T t);
    }
    //方法一
    /*class Demo implements Inter<String>{  //推荐用这种
        public void show(String t){
            System.out.println(t);
        }
    }*/
    //方法二
    class Demo<T> implements Inter<T>{  //没有必要在实现泛型接口的时候给自己类加上泛型
        public void show(T t){
            System.out.println(t);
        }
    }
}

16.12_集合框架(泛型高级之通配符)(了解)

  • A:泛型通配符
public static void main(String[] args) {
        //List<?> list = new ArrayList<String>(); 
        //当右边的泛型类型不确定时，左边可以定义为？

        // TODO Auto-generated method stub
        ArrayList<Person> alist = new ArrayList<>();
        alist.add(new Person("账单",23));
        alist.add(new Person("账单11",24));

        ArrayList alist2 = new ArrayList();
        alist2.add(new Student("张三",25));
        alist2.add(new Student("张三11",26));
        alist2.add(new Worker("heu",23));

        //addAll(Collection<? extends E> c)  将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
        //alist2必须是继承alist的，才能加进去。即Student，worker类都继承自Person，所以可以加进去
        alist.addAll(alist2);   //向下限定，E及其子类。
        alist2.addAll(alist);  //不可以，报错！
        System.out.println(alist);
    }

16.13_JDK1.5新特性（5点）

自动拆装箱、增强for、静态导入、可变参数

16.13_集合框架(增强for的概述和使用)(掌握)

  • A:增强for概述
    • 简化数组和Collection集合的遍历
  • B:格式：

  • for(元素数据类型 变量 : 数组或者Collection集合) {
    使用变量即可，该变量就是元素
    }
  • C:案例演示
    • 数组，集合存储元素用增强for遍历
  • D:好处
    • 简化遍历
public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Student> alist =new ArrayList<>();
        alist.add(new Student("张三",23));
        alist.add(new Student("张si",24));
        alist.add(new Student("张wu",25));

        for(Student iValue : alist){    System.out.println(iValue.getName()+"..."+iValue.getAge());
        }
    }

16.14_集合框架(ArrayList存储字符串和自定义对象并遍历增强for版)(掌握)

  • A:案例演示

    • ArrayList存储字符串并遍历增强for版
    • ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");

for(String s : list) {
    System.out.println(s);
}

16.15_集合框架(三种迭代的能否删除)(掌握)

  • 普通for循环,可以删除,但是索引要–
  • 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
  • 增强for循环不能删除
//方法一：普通for循环删除自定义对象元素
ArrayList<Student> alist =new ArrayList<>();
        alist.add(new Student("张三",23));
        alist.add(new Student("张si",24));
        alist.add(new Student("张wu",25));

        for(int i = 0;i<alist.size();i++){
            if(new Student("张三",23).equals(alist.get(i))){
                alist.remove(i--);
            }
        }
        System.out.println(alist);
private static void Demo1(ArrayList<String> alist) {

    //方法一：普通for循环,删除String对象
        for(int i = 0; i < alist.size(); i++){
            if("张si".equals(alist.get(i))){
                alist.remove(i);//注：remove之后，alist后面的元素向前移动，但马上指针就要++，所以会错过检查刚才删除的下一个元素，此时，要有i--
                i--;
            }
        }
        System.out.println(alist);
    }
    private static void Demo2(ArrayList<String> alist) {
    //方法二：iterator迭代，用迭代器自己的删除方法，否则会报并发修改异常
        Iterator<String> itr = alist.iterator();
        while(itr.hasNext()){
            if("张si".equals(itr.next())){
                itr.remove();   
            }
        }
        System.out.println(alist);
//增强for不能删除，会报并发修改异常

16.16_集合框架(静态导入的概述和使用)(掌握)

  • A:静态导入概述
  • B:格式：
    • import static 包名….类名.方法名;
    • 可以直接导入到方法的级别
  • C:注意事项
    • 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

16.17_集合框架(可变参数的概述和使用)(掌握)

  • A:可变参数概述
    • 定义方法的时候不知道该定义多少个参数
  • B:格式
    • 修饰符 返回值类型 方法名(数据类型… 变量名){}
  • C:注意事项：
    • 这里的变量其实是一个数组
    • 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
package com.hongwei.foreach;
public class Demo3_changeableArgs {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr ={11,22,33,44,55};
        print(arr);
        print(11,22,33,44,55);
        print("a",11,22,33);
    }
    /*public static void print(int[] arr){ 
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }*/

    public static void print(int...arr){  //可变参数相当于一个数组
        for(int i=0;i<arr.length;i++){  
            System.out.println(arr[i]);
        }
    }
    public static void print(String s,int...arr){  //有多个参数时，可变参数放在最后
        for(int i=0;i<arr.length;i++){  
            System.out.println(arr[i]);
        }
    }
}

16.18_集合框架(Arrays工具类的asList()方法的使用)(掌握)

  • A:案例演示
    • Arrays工具类的asList()方法的使用
    • Collection中toArray(T[] a)泛型版的集合转数组
public class Demo4_asList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr ={11,22,33,44,55};
        List list = Arrays.asList(arr);
        System.out.println(list); 
        //输出结果：[[I@15db9742]，基本数据类型数组转集合，会把数组当作一整个对象

        Integer[] arr1 ={11,22,33,44,55};
        List list1 = Arrays.asList(arr1);
        list.add(11111); //java.lang.UnsupportedOperationException异常，操作不能进行，数组转集合，不能添加减少元素
        System.out.println(list1); //输出结果：[11, 22, 33, 44, 55]，将数组转换为集合，数组必须是引用数据类型 
    }

16.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)

  • A:案例演示
    • 集合嵌套之ArrayList嵌套ArrayList
public class Demo5_ArrayListArrayList {

    /**
     * 集合嵌套之ArrayList嵌套ArrayList
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<ArrayList<Person>> alist =  new ArrayList<ArrayList<Person>>();

        ArrayList<Person> firstList = new ArrayList<Person>();
        firstList.add(new Person("张三",23));
        firstList.add(new Person("张四",24));
        firstList.add(new Person("张五",25));

        ArrayList<Person> secondList = new ArrayList<Person>();
        secondList.add(new Person("2张三",223));
        secondList.add(new Person("2张四",224));
        secondList.add(new Person("2张五",225));

        alist.add(firstList);
        alist.add(secondList);

        for(ArrayList<Person> perList:alist){
            for(Person p:perList){
                System.out.println(p);
            }
        }       
    }
}

16.20_day16总结

  • 把今天的知识点总结一遍。
秋天1014童话
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值