Java集合框架（二）day_16

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java集合框架（二）day_16，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11334字，纯文字阅读大概需要17分钟。

内容图文

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

            
                public
                
                    class
                    Demo1_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("c");
        list.add("c");
        list.add("c");
        list.add("c");

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

    /*
     * 创建新集合将重复元素去掉
     * 1,明确返回值类型,返回ArrayList
     * 2,明确参数列表ArrayList
     * 
     * 分析:
     * 1,创建新集合
     * 2,根据传入的集合(老集合)获取迭代器
     * 3,遍历老集合
     * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
     */publicstatic ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList<>();                  //1,创建新集合
        Iterator it = list.iterator();                          //2,根据传入的集合(老集合)获取迭代器while(it.hasNext()) {                                   //3,遍历老集合
            Object obj = it.next();                             //记录住每一个元素if(!newList.contains(obj)) {                        //如果新集合中不包含老集合中的元素
                newList.add(obj);                               //将该元素添加
            }
        }

        return newList;
    }
}
###16.集合框架(去除ArrayList中重复自定义对象元素)(掌握)
* A:案例演示
    * 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
* B:注意事项
    * 重写equals()方法的
publicclassDemo2_ArrayList {/**
     * * A:案例演示
            * 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
        * B:注意事项
            * 重写equals()方法的
        contains方法判断是否包含,底层依赖的是equals方法
        remove方法判断是否删除,底层依赖的是equals方 */publicstaticvoidmain(String[] args) {
ArrayList list = new ArrayList();//创建集合对象
list.add(new Person("张三", 23));
list.add(new Person("张三", 23));
list.add(new Person("李四", 24));
list.add(new Person("李四", 24));
list.add(new Person("李四", 24));
list.add(new Person("李四", 24));

//ArrayList newList = getSingle(list);//调用方法去除重复//System.out.println(newList);
list.remove(new Person("张三", 23));
System.out.println(list);
}

/*
 * 创建新集合将重复元素去掉
 * 1,明确返回值类型,返回ArrayList
 * 2,明确参数列表ArrayList
 * 
 * 分析:
 * 1,创建新集合
 * 2,根据传入的集合(老集合)获取迭代器
 * 3,遍历老集合
 * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
 */publicstatic ArrayList getSingle(ArrayList list) {
ArrayList newList = new ArrayList<>();//1,创建新集合
Iterator it = list.iterator();//2,根据传入的集合(老集合)获取迭代器while(it.hasNext()) {//3,遍历老集合
Object obj = it.next();//记录住每一个元素if(!newList.contains(obj)) {//如果新集合中不包含老集合中的元素
newList.add(obj);//将该元素添加
}
}

return newList;
}
}
publicclassPerson {private String name;
privateint age;
publicPerson() {
super();

}
publicPerson(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
publicvoidsetName(String name) {
this.name = name;
}
publicintgetAge() {
return age;
}
publicvoidsetAge(int age) {
this.age = age;
}
@Overridepublic 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;
}*/

}03_集合框架(LinkedList的特有功能)(掌握)
* A:LinkedList类概述
* B:LinkedList类特有功能
    * publicvoidaddFirst(E e)及addLast(E e)
    * public E getFirst()及getLast()
    * public E removeFirst()及public E removeLast()
    * public E get(int index);

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

###16集合框架(用LinkedList模拟栈数据结构的集合并测试)(掌握)
* A:案例演示
    * 需求：请用LinkedList模拟栈数据结构的集合，并测试
    * 创建一个类将Linked中的方法封装
    * 
            publicclassStack {private LinkedList list = new LinkedList();     //创建LinkedList对象publicvoidin(Object obj) {
                    list.addLast(obj);                          //封装addLast()方法
                }

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

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

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

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

     */
                public
                static
                void
                main(String[] args) {
        //demo1();//int[] arr = new byte[5];                          //数组要保证前后的数据类型一致//ArrayList<Object> list = new ArrayList<Person>(); //集合的泛型要保证前后的数据类型一致//ArrayList<Object> list = new ArrayList<>();       //1.7版本的新特性,菱形泛型
        ArrayList<Object> list = new ArrayList<>();         //泛型最好不要定义成Object,没有意义
        list.add("aaa");
        list.add(true);
    }

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

        Iterator<Person> it = list.iterator();
        while(it.hasNext()) {
            //System.out.println(it.next());//System.out.println(it.next().getName() + "..." + it.next().getAge());//next方法只能调用一次,如果调用多次会将指针向后移动多次
            Person p = it.next();           
            System.out.println(p.getName() + "..." + p.getAge());
        }
    }

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

            *publicclassDemo2_Generic {/**
     * * A:案例演示
     * ArrayList存储字符串并遍历泛型版
     */publicstaticvoidmain(String[] args) {
        //demo1();
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王五", 25));
        list.add(new Person("赵六", 26));

        Iterator<Person> it = list.iterator();
        while(it.hasNext()) {
            Person p = it.next();                           //将集合中的每一个元素用Person记录
            System.out.println(p.getName() + "..." + p.getAge());
        }
    }

    publicstaticvoiddemo1() {
        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.08_集合框架(泛型的由来)(了解)

            
                public
                
                    class
                    Demo3_Generic {
                /**
     * A:案例演示
     * 泛型的由来:通过Object转型问题引入
     * 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
     */
                public
                static
                void
                main(String[] args) {
        //demo1();
        Tool<String> t = new Tool<>();
        //t.show("abc");
        t.show(true);
    }

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

        //Worker w = (Worker) t.getObj();           //向下转型//System.out.println(w);
    }

}

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

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

            
                public
                static
                void main(String[] args) {

    }
}

interfaceInter<T> {publicvoid show(T t);
}

/*class Demo implements Inter<String> {     //推荐用这种

    @Override
    public void show(String t) {
        System.out.println(t);
    }

}*/classDemo<T> implementsInter<T> {//没有必要在实现接口的时候给自己类加泛型

    @Override
    publicvoid show(T t) {
        System.out.println(t);
    }

}

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

A:泛型方法概述
- 把泛型定义在方法上
B:定义格式
- public <泛型类型> 返回类型方法名(泛型类型变量名)
C:案例演示
- 泛型方法的使用

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

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

            
                public
                static
                void main(String[] args) {

    }
}

interfaceInter<T> {publicvoid show(T t);
}

/*class Demo implements Inter<String> {     //推荐用这种

    @Override
    public void show(String t) {
        System.out.println(t);
    }

}*/classDemo<T> implementsInter<T> {//没有必要在实现接口的时候给自己类加泛型

    @Override
    publicvoid show(T t) {
        System.out.println(t);
    }

}

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

A:泛型通配符

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

A:增强for概述
- 简化数组和Collection集合的遍历
B:格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
C:案例演示
- 数组，集合存储元素用增强for遍历
D:好处
- 简化遍历

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循环不能删除

            * publicclass Demo1_Foreach {

    /**
     * * A:增强for概述
            * 简化数组和Collection集合的遍历
        * B:格式：
        * 
                for(元素数据类型 变量 : 数组或者Collection集合) {
                    使用变量即可，该变量就是元素
                }
        * C:案例演示
            * 数组，集合存储元素用增强for遍历
        * D:好处
            * 简化遍历
        增强for循环底层依赖的是迭代器(Iterator)
     */publicstaticvoid main(String[] args) {
        //demo1();//demo2();
        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();
            }
        }*//*for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
            if("b".equals(it2.next())) {
                //list.remove("b");                         //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
                it2.remove();
            }
        }*///3,增强for循环,增强for循环不能删除,只能遍历for (String string : list) {
            if("b".equals(string)) {
                list.remove("b");
            }
        }
        System.out.println(list);
    }

    publicstaticvoid demo2() {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王五", 25));
        list.add(new Person("赵六", 26));

        for (Person person : list) {
            System.out.println(person);
        }
    }

    publicstaticvoid demo1() {
        int[] arr = {11,22,33,44,55};
        for (int i : arr) {
            System.out.println(i);
        }

        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

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

}

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

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

             */
    publicstaticvoidmain(String[] args) {
        int[] arr = {55,22,33,44,11};
        sort(arr);                          //排序//System.out.println(toString(arr));
    }



}

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

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

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

    /*public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }*/publicstaticvoidprint(int ... arr) {         //可变参数其实是一个数组for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

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

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

            
                public
                
                    class
                    Demo4_AsList {
                /**
     * 数组转换成集合
     * 数组转换成集合虽然不能增加或减少元素,但是可以用集合的思想操作数组,也就是说可以使用其他集合中的方法
     */
                public
                static
                void
                main(String[] args) {
        //demo1();//demo2();//集合转数组,加泛型的
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        String[] arr = list.toArray(new String[10]);        //当集合转换数组时,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size//如果数组的长度大于了size,分配的数组长度就和你指定的长度一样for (String string : arr) {
            System.out.println(string);
        }
    }

    publicstaticvoiddemo2() {
        //int[] arr = {11,22,33,44,55};         //List<int[]> list = Arrays.asList(arr);            基本数据类型的数组转换成集合,会将整个数组当作一个对象转换//System.out.println(list);
        Integer[] arr = {11,22,33,44,55};                   //将数组转换成集合,数组必须是引用数据类型
        List<Integer> list = Arrays.asList(arr);
        System.out.println(list);
    }

    publicstaticvoiddemo1() {
        String[] arr = {"a","b","c"};
        List<String> list = Arrays.asList(arr);             //将数组转换成集合//list.add("d");                                    //不能添加
        System.out.println(list);
    }

}

原文：http://blog.csdn.net/qq_16103331/article/details/52008549

内容总结

以上是互联网集市为您收集整理的Java集合框架（二）day_16全部内容，希望文章能够帮你解决Java集合框架（二）day_16所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1134153.html

来源：【匿名】

【上一篇】java对象四种引用原理【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java集合框架（二）day_16】教程文章相关的互联网学习教程文章

Vector：　　　　底层也是维护了一个Object数组，实现与ArrayList是一样的，　　　　但其线程是安全的，效率低。除了比较老的系统，是不会用到的。笔试题：ArrayList 和 Vector 的区别。相同点：都是底层维护了一个Object数组。（看源码）不同点：ArrayList 是线程不同步地，操作效率高。（1.2）后来代替了Vector　　　　Vector 线程同步的，操作效率低。（1.0）原文：http://www.cnblogs.com/lifehrx/p/5797057.html

Java基础知识强化之集合框架笔记53：Map集合之Map集合的遍历键值对对象找键和值【代码】【图】

1. Map集合的遍历（键值对对象找键和值）Map -- 夫妻对思路： A: 获取所有结婚证的集合 B: 遍历结婚证的集合，得到每一个结婚证 C: 根据结婚证获取丈夫和妻子转换： A: 获取所有键值对对象的集合 B: 遍历键值对对象的集合，得到每一个键值对对象 C: 根据键值对对象获取键和值 2. 代码示例： 1package cn.itcast_01;2 3import java.util.HashMap;4import java.util.Map;5import java.util.Set;6 7/* 8 * 看看我们开始的一个方...

java基础——集合【代码】【图】

集合与数组的区别： 1.数组是固定长度的；集合的长度是可变的。 2.数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。 3.数组存储元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。 java集合主要有3种重要的类型： ●List：是一个有序集合，可以存放重复的数据。 ●Set: 是一个无序集合，不允许存放重复的数据。 ●Map: 是一个无序集合，集合中包含一个键对象和一个值对象，键对象不...

Java源码之集合框架（图）【图】

百度java 集合图时，搜出来一张图，图的蛮不错的，现在借用一下。图片来自：http://blog.csdn.net/bondsui/article/details/8520078原文：http://blog.csdn.net/itismelzp/article/details/50554921

java中求两个数组（集合）的交集，并集，差集【代码】

对于两个数组arr1=[1,3,4,5,8,9]arr2=[2,3,7,8,9]求出交集与并集test.java 1import java.util.ArrayList;2import java.util.Collections;3 4 5publicclass test1 {6publicstaticvoid main(String[] args) {7 ArrayList<Integer> tmplist=new ArrayList<Integer>();8int[] arr1={1,3,4,5,8,9};9int[] arr2={2,3,7,8,9}; 10 tmplist=Intersection(arr1,arr2); 11 OutPut(tmplist); 12 tmplist.clear(); 13 tmplist...

java复习 --集合类【图】

List接口：可以存放重复内容；set接口：不能存放重复内容，重复内容依靠hashcode和equal两个方法来区分；Queue：队列；SortedSet接口：对集合中的数据进行排序； List接口：List子类：ArrayList,VectorArrayList和Vector的区别：LinkedList类和queue接口LinedList 链表的操作类Queue接口是Collection的子接口 Set接口：Set接口是collection接口的子接口，但是和Collection或者List接口不同的是：set不能加入重复元素。set的主要方法...

java集合之LinkedList【代码】

1.LinkedList是什么？有什么特点　　LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList 实现 List 接口，能对它进行队列操作。LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。Linke...

java中的集合类【图】

实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。上述所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是add(),previous(),hasPrevious()。也...

java 数据类型：集合接口Collection之队列Queue:PriorityQueue ;Dequeue【图】

什么是Queue集合：Queue用于模拟队列这种数据结构，队列通常是“先进先出”（FIFO）的容器。队列的头部保存在队列中存放时间最长的元素，尾部保存存放时间最短的元素。 Queue接口定义了如下几个方法：void add(Object e):将制定的元素加入队列的尾部Object element(): 获取队列的头部元素，但不要删除改元素boolean offer(Object e): 将制定元素加入此队列的尾部。当使用有容量限制的队列的时候，该方法比add方法更好Object peek(...

Java自学-集合框架 HashMap和Hashtable的区别【代码】【图】

HashMap和Hashtable之间的区别步骤 1 : HashMap和Hashtable的区别HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式区别1： HashMap可以存放 null Hashtable不能存放null 区别2： HashMap不是线程安全的类 Hashtable是线程安全的类package collection;import java.util.HashMap; import java.util.Hashtable;public class TestCollection {public static void main(String[] args) {//HashMap和Hashtable都实现了Map接...

Java并发(四):并发集合ConcurrentHashMap的源码分析【代码】【图】

之前介绍了Java并发的基础知识和使用案例分析,接下来我们正式地进入Java并发的源码分析阶段,本文作为源码分析地开篇,源码参考JDK1.8OverView:　　JDK1.8源码中的注释提到:ConcurrentHashMap是一种提供完整的并发检索和对于并发更新有高预测性的散列表,遵循了与HashMap相同的功能性规格,并包含与HashTable每个方法都对应的方法.虽然所有操作都是线程安全的,但检索操作并不牵涉任何锁,不支持任何锁住整个散列表来保护所有的访问.　　...

Java基础——集合【代码】

存储对象可以考虑：数组，集合　　数组存储对象特点：Student[] stu = new Student[23]; str[0] = new Student();... 　　　　弊端：1.一旦创建，其长度不可改变　　　　　　　2.真实的数组存放的对象的个数是不可知的Java集合可分为Collection和Map两种体系： Collection接口：　　List接口：有序的，可重复元素相当于“动态”数组　　　　添加进List集合中的元素（或对象）所在的类一定要重写equals()方法；　　　　|---Ar...

java28：集合类2【代码】

增强for 循环 java 1.5 之后：用于遍历集合和数组（简化了遍历集合和数组的操作）for(ELEMENT_TYPE e : LIST_ARRAY){} 新循环是使用迭代器的形式实现的不要通过集合删除元素 for(String str : list){ System.out.println(str); list.remove(str);//报错不能删除 }package day28;import java.util.ArrayList; import java.util.Collection;public class Demo01 {public static void main...

java集合（四）Set集合之HashMap详解【代码】【图】

一、概要第1部分概要第2部分 HashMap介绍第3部分 HashMap数据结构第4部分 HashMap源码解析(基于JDK1.6.0_45) 第4.1部分 HashMap的“拉链法”相关内容第4.2部分 HashMap的构造函数第4.3部分 HashMap的主要对外接口第4.4部分 HashMap实现的Cloneable接口第4.5部分 HashMap实现的Serializable接口第5部分 HashMap遍历方式第6部分 HashMap示例二、HashMap介绍HashMap简介HashMap 是一个散列表，它存储的内容是键值...

Java 集合之 Collection【代码】【图】

集合就是一组数的集合，就像是一个容器，但是我们应该清楚的是集合中存放的都是对象的引用，而不是真正的实体。而我们常说的集合中的对象其实指的就是对象的引用。我们可以把集合理解为一个小型数据库，用于存放数据，我们对集合的操作也就是数据的增删改查，在 Java 中有两个顶层接口 Collection 和 Map 用于定义和规范集合的相关操作。这篇文章主要说一下集合框架中的 Collection 部分。 Collection 表示一组对象，这些对象可以...

首页 / JAVA / Java集合框架（二）day_16

Java集合框架（二）day_16

内容导读

内容图文

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

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

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

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

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

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

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

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

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

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

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

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

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

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

内容总结

内容备注

内容手机端

【Java集合框架（二）day_16】教程文章相关的互联网学习教程文章

集合 - 相关标签

框架 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程