【java】集合类-2

文章目录

1. 泛型简介
- 1.1 泛型类
- 1.2 泛型方法
- 1.3 泛型接口
- 1.4 泛型通配符
2 Map集合简介
- 2.1 Map集合的方法
- 2.2 Map集合的遍历
- 2.3 HashMap集合
- 2.4 LinkedHashMap集合
- 2.5 TreeMap集合
- 2.6 集合名称阅读技巧

1. 泛型简介

在jDK1.4之前，容器什么类型的对象都能存储，但是取出时，需要用到对象的特有内容时，需要向下转型。但是对象的类型不一致，导致向下转型发生了ClassCastException，为了避免这个问题，只能主观上控制往集合中存储的对象类型保持一致。
JDK1.5解决了这个问题，在定义集合时，就直接明确集合中存储元素的具体类型，这样，编译器在编译时，就可以对集合中存储的对象类型进行检查，一旦发现类型不匹配，就编译失败，这个技术就是泛型技术。

代码示例1：
在定义集合容器时不加泛型

public class GenericDemo
{public static void main(String[] args){List list = new ArrayList();list.add("abc");for(Iterator<String> it = list.iterator();it.hasNext();){//Object obj = it.next();//需要强制转换String s = (String)it.next();}    }
}

代码示例2：
在定义集合容器时加入泛型,集合中存储的元素类型为字符串类型

public class GenericDemo
{public static void main(String[] args){//集合里面不能存放基本数据类型//为了在运行时期不出现类型异常，，可以在定义容器时就明确容器中元素的类型List<String> list = new ArrayList<String>();list.add("abc");for(Iterator<String> it = list.iterator();it.hasNext();){String s = it.next();}   }
}

代码示例3:
加入泛型，集合中存储的元素类型为整型

public class GenericDemo2
{public static void main(String[] args){//创建一个List集合，存储整数List<Integer> list = new ArrayList<Integer>();list.add(4);list.add(5);list.add(6);list.add(7);//这里使用了增强for//for(元素类型 变量：Collection容器或数组){ } for(Integer s : list){System.out.println(s);}   }
}

代码示例4：
集合中存储的类型为字符串类型，使用增强for遍历

public class GenericDemo3
{public static void main(String[] args){Set<String> set = new TreeSet<String>();set.add("abc");set.add("abc1");set.add("abc2");set.add("abc3");//增强forfor(String s:set){System.out.println(s);}}
}

代码示例5：
集合中存储的类型为自定义类型

public class GenericDemo4
{public static void main(String[] args){Set<Person> set = new TreeSet<Person>();set.add(new Person("aa",20));set.add(new Person("bbd",21));set.add(new Person("ccw",22));set.add(new Person("ddq",23));for(Person p : set){System.out.println(p);}}
}

1.1 泛型类

泛型类：把泛型定义在类上
代码示例1：

public class GenericDemo5
{public static void main(String[] args){    Util<Student> util = new Util<Student>();util.setObj(new Student());//util.setObj(new Worker());类型不匹配直接编译失败Student stu = util.getObj();System.out.println(stu);}
}//在类定义时，就明确参数，由使用该类的调用者，来传递具体的类型
class Util<w>//泛型类
{private w obj;public w getObj(){return obj;}public void setObj(w obj){this.obj = obj;}
}

代码示例2：

class ObjectTool<T>
{private T obj;public T getObj(){return obj;}public void setObj(T obj){this.obj = obj;}
}
public class ObjectToolDemo
{public static void main(String[] args){    ObjectTool<String> ot = new ObjectTool<String>();ot.setObj(new String("kk"));String s = ot.getObj();System.out.println("姓名："+s);ObjectTool<Integer> ot2 = new ObjectTool<Integer>();ot2.setObj(new Integer(30));Integer i = ot2.getObj();System.out.println("年龄："+i);}
}

1.2 泛型方法

泛型方法：把泛型定义在方法上，可以接受任意类型的数据。

代码示例1：

class ObjectTool
{public<T> void show(T t){System.out.println(t);}
}
public class ObjectToolDemo
{public static void main(String[] args){        //方法的泛型类型和类上的泛型类型相同ObjectTool<String> ot1 = new ObjectTool<String>();ot1.show("hello");ObjectTool<Integer> ot2 = new ObjectTool<Integer>();ot2.show(10);ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();ot3.show(true);//方法的类型和类上的类型不相同,此时仍然可以接收任意类型ObjectTool<Integer> ot = new ObjectTool<Integer>();ot.show("String");ot.show(100);ot.show(true);            }
}

代码示例2：

public class GenericDemo6
{class Demo<W>{public void show(W w){System.out.println("show:"+w);}public<Q> void print(Q w)//泛型方法{System.out.println("print:"+w);}}public static void main(String[] args){//方法的泛型类型和类的泛型类型相同Demo<String> d = new Demo<String>();d.show("abc");d.print(6);//方法的泛型类型和类的泛型类型不同Demo<Integer> d1 = new Demo<Integer>();d1.show("abc");//报错d1.print(6);Demo<String> d1 = new Demo<String>();d1.show("abx");d1.print(6);d1.print("as");}
}

1.3 泛型接口

泛型接口：将泛型定义在接口上

public class GenericDemo7
{public static void main(String[] args){SubDemo sb = new SubDemo();sb.show("abc");}
}
interface Inter<T>
{public void show(T t);
}
class InterImple<W> implements Inter<W>
{public void show(W t){System.out.println("show："+t);}
}
class SubDemo extends InterImple<String>
{
}

1.4 泛型通配符

泛型高级（通配符）

?:任意的类型都可以
? extends E:向下限定，E及其子类
? super E:向上限定，E及其父类

代码示例1：

public class GenericDemo
{public static void main(String[] args){//泛型如果明确的时候，前后必须一致Collection<Object> c = new ArrayList<Object>();//Collection<Object> c1 = new ArrayList<Animal>();//Collection<Object> c2 = new ArrayList<Cat>();//Collection<Object> c3 = new ArrayList<Dog>();//?表示任意的类型都可以Collection<?> c5 = new ArrayList<Object>();Collection<?> c6 = new ArrayList<Animal>();Collection<?> c7 = new ArrayList<Dog>();Collection<?> c8 = new ArrayList<Cat>();//? exends 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> c13 = new ArrayList<Object>();Collection<? super Animal> c14 = new ArrayList<Animal>();//Collection<? super Animal> c15 = new ArrayList<Dog>();//Collection<? super Animal> c16 = new ArrayList<Cat>(); }}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

2 Map集合简介

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。
如果把Map里的所有key放在一起来看，它们就组成了一个Set集合（所有的key没有顺序，key与key之间不能重复）
如果把Map里的所有value放在一起来看，它们又非常类似于一个List：元素与元素之间可以重复，每个元素可以根据索引来查找
Map集合和Collection集合的区别：
Map集合存储元素是成都出现的，Map集合的键是唯一的，值可以是重复的
Collection集合存储的元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的
Map集合的数据结构与特点：
Map集合的数据结构只针对键有效，跟值无关

2.1 Map集合的方法

功能	方法	说明
添加功能	V put(K key, V value)	如果键是第一次存储，就直接存储元素，返回null如果不是第一次存储，就把以前的值替换掉，返回以前的值
删除功能	void clear()	移除所有的键值对元素
删除功能	V remove(Object key)	根据建删除键值对元素
长度功能	int size()	返回集合中键值对的对数
判断功能	boolean containsKey(Object key)	判断集合是否包含指定的键
判断功能	boolean containsValue(Object value)	判断集合是否包含指定的值
判断功能	boolean isEmpty()	判断集合是否为空
获取功能	V get(Object key)	根据键获取值
获取功能	Set keySet()	获取集合中所有键的集合
获取功能	Collection values()	获取集合中所有值的集合
获取功能	Set<Map.Entry<K,V>> entrySet()	火气键值对对象的集合

代码示例1：

public class MapDemo
{public static void main(String[] args){/** Map集合存储学号和姓名*/Map<Integer,String> map = new HashMap<Integer,String>();methodDemo(map);}public static void methodDemo(Map<Integer,String>map){//存储键值对,如果键相同，会出现值覆盖System.out.println(map.put(3,"hh"));//null//如果键是第一次存储，就直接存储元素，返回nullSystem.out.println(map.put(3,"kk"));//hh//如果不是第一次存储，就把以前的值替换掉，返回以前的值。map.put(4,"yy");map.put(5,"jj");System.out.println(map);//{3=kk, 4=yy, 5=jj}}
}

代码示例2：

public class MapDemo
{public static void main(String[] args){//创建集合对象Map<String,String> map = new HashMap<String,String>();//添加元素map.put("邓超", "孙俪");map.put("黄晓明", "杨颖");map.put("周杰伦", "蔡依林");map.put("杨幂", "刘恺威");//map{邓超=孙俪, 杨幂=刘恺威, 周杰伦=蔡依林, 黄晓明=杨颖}//(2)void clear()移除所有的键值对元素map.clear();//map{}//(3)V remove(Object key)根据建删除键值对元素System.out.println("remove:"+map.remove("黄晓明"));//map{邓超=孙俪, 杨幂=刘恺威, 周杰伦=蔡依林}//(4)boolean containsKey(Object key)判断集合是否包含指定的键System.out.println(map.containsKey("黄晓明"));//(5)boolean containsValue(Object value)判断集合是否包含指定的值System.out.println(map.containsValue("杨颖"));//(6)boolean isEmpty()判断集合是否为空System.out.println(map.isEmpty());//(7)int size()返回集合中键值对的对数System.out.println(map.size());//输出集合名称System.out.println("map"+map);       }
}

代码示例2：

Map集合的获取功能
V get(Object key) ：根据建获取值
Set keySet() ：获取集合中所有键的集合
Collection values()：获取集合中所有值的集合

public class MapDemo1
{public static void main(String[] args){//创建集合对象Map<String,String> map = new HashMap<String,String>();//创建并添加元素map.put("邓超", "孙俪");map.put("黄晓明", "杨颖");map.put("周杰伦", "蔡依林");map.put("杨幂", "刘恺威");//(1)V get(Object key)根据建获取值System.out.println(map.get("周杰伦"));//蔡依林//(2)Set<K> keySet()获取集合中所有键的集合Set<String> set = map.keySet();for(String key :set){System.out.println(key);}//(3)Collection<V> values()获取集合中所有值的集合Collection<String> v = map.values();for(String value:v){System.out.println(value);}}
}

2.2 Map集合的遍历

先获取所有的键，再根据建来找值
获取键值对对象的集合，根据键值对对象获取键和值

代码示例1：

public class MapDemo2
{public static void main(String[] args){//创建集合对象Map<String,String> map = new HashMap<String,String>();//创建元素并添加集合map.put("杨过", "小龙女");map.put("郭靖", "黄蓉");map.put("杨康", "穆念慈");map.put("陈选", "梅超风");//遍历//获取所有的键Set<String> set = map.keySet();for(String key:set){//根据建去找值String value  = map.get(key);System.out.println(key+"---"+value);}      }
}

代码示例2：

public class MapDemo4
{public static void main(String[] args){//创建集合对象Map<String,String> map = new HashMap<String,String>();//添加元素map.put("杨过", "小龙女");map.put("郭靖", "黄蓉");map.put("杨康", "穆念慈");map.put("陈选", "梅超风");//Set<Map.Entry<K,V>> entrySet()返回键值对对象的集合Set<Map.Entry<String,String>> set = map.entrySet();//遍历键值对对象的集合for(Map.Entry<String,String> me :set){//根据键值对对象得到键和值String key = me.getKey();String value = me.getValue();System.out.println(key+"---"+value);}       }
}

代码示例3：

public class MapDemo2
{public static void main(String[] args){/** 取出Map中所有的元素* map存储姓名--归属地*/Map<String,String> map = new HashMap<String,String>();map.put("xiaoqing","beijiang");map.put("xiaoinh","sahnghai");map.put("liuyi","nanjing");map.put("huhua","anhui");//keySet()取出所有的键并存储到集合中//Map集合没有迭代器，但是可以将Map集合转成Set集合，再使用迭代器Set<String> keySet = map.keySet();for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext();){String key = iterator.next();String value = map.get(key);System.out.println(key+":"+value);     }//演示entrySet()Set<Map.Entry<String, String>> entrySet = map.entrySet();//用增强for比用迭代器更简单点for (Iterator<Map.Entry<String, String>> iterator = entrySet.iterator(); iterator.hasNext();){Map.Entry<String, String> me = iterator.next();String key = me.getKey();String value = me.getValue();System.out.println(key+":"+value);           }//演示values()方法:获取所有的值Collection<String> values = map.values();for (Iterator<String> iterator = values.iterator(); iterator.hasNext();){String value = iterator.next();System.out.println(value);            }}
}

2.3 HashMap集合

HashMap:基于哈希表的Map接口实现，哈希表的作用是用来保证键的唯一性

代码示例1：

HashMap<String,String>
键：string
值：String

public class HashMapDemo
{public static void main(String[] args){//创建集合对象HashMap<String,String> hm = new HashMap<String,String>();//创建元素并添加hm.put("it001", "马云");hm.put("it002", "马化腾");hm.put("it003", "乔布斯");hm.put("it004", "张朝阳");hm.put("it005", "求伯君");hm.put("it001", "比尔盖茨");//遍历Set<String> set = hm.keySet();for(String key:set){String value = hm.get(key);System.out.println(key+"---"+value);}             }
}

代码示例2：

HashMap<Integer,String>
键：Integer
值：String

 public class HashMapDemo2
{public static void main(String[] args){//创建集合对象HashMap<Integer,String> hm = new HashMap<Integer,String>();hm.put(27, "林青霞");hm.put(28, "风清扬");hm.put(29, "刘意");hm.put(23, "林青霞");//遍历Set<Integer> set = hm.keySet();for(Integer key:set){String value = hm.get(key);System.out.println(key+"---"+value);} }
}

代码示例3：

HashMap<String,Student>
键：String
值：Student

public class HashMapDemo3
{public static void main(String[] args){//创建集合对象HashMap<String,Student> hm = new HashMap<String,Student>();//创建学生对象Student s1 = new Student("周星驰",51);Student s2 = new Student("刘德华",55);Student s3 = new Student("梁朝伟",55);Student s4 = new Student("刘嘉玲",50);//添加元素hm.put("9527", s1);hm.put("9528", s2);hm.put("9529", s3);   hm.put("9522", s4);//遍历Set<String> set = hm.keySet();for(String key:set){Student value = hm.get(key);System.out.println(key+"---"+value.getAge()+"---"+value.getName());}}
}

代码示例4：

HashMap<Student,String>
键：Student，如果两个对象的成员变量值都相同，则为同一个对象
值：String
注意，键的数据结构为哈希结构，哈希结构的底层为hasnCode()和equals()方法因此，Student类中需重写这两个方法，才能保证唯一性

class Student
{private String name;private int age;public Student(){super();// TODO Auto-generated constructor stub}public Student(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;}@Overridepublic int hashCode(){final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj){if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Student other = (Student) obj;if (age != other.age)return false;if (name == null){if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}
}
public class HashMapDemo4
{public static void main(String[] args){//创建集合对象HashMap<Student,String> hm = new HashMap<Student,String>();//创建学生对象Student s1 = new Student("貂蝉",27);Student s2 = new Student("王昭君",30);Student s3 = new Student("杨玉环",233);Student s4 = new Student("西施",36);Student s5 = new Student("貂蝉",27);//添加元素hm.put(s1, "8888");hm.put(s2, "6666");hm.put(s3, "7777");hm.put(s4, "5555");hm.put(s5, "9999");//遍历Set<Student> set = hm.keySet();for(Student key:set){String value = hm.get(key);System.out.println(key.getAge()+"---"+key.getName()+"---"+value);}}
}

2.4 LinkedHashMap集合

LinkedHashMAp：是Map结构的哈希表和链接列表实现，具有可预知的迭代顺序
由哈希表保证键的唯一性
由链表保证键的有序性（存储和取出的顺序一致）

public class LinkedHashMapDemo
{public static void main(String[] args){//创建集合对象LinkedHashMap<String,String> hm = new LinkedHashMap<String,String>();//创建并添加元素hm.put("2345", "hello");hm.put("1234", "world");hm.put("3456", "java");hm.put("1234", "javaee");hm.put("3456", "andriod");//遍历Set<String> set = hm.keySet();for(String key:set){String value = hm.get(key);System.out.println(key+"---"+value);}}
}

2.5 TreeMap集合

TreeMap：是基于红黑树的Map接口的实现

代码示例1:

public class TreeMapDemo
{public static void main(String[] args){//创建集合对象TreeMap<String,String> tm = new TreeMap<String,String>();//创建并添加元素tm.put("hello", "你好");tm.put("world", "世界");tm.put("java", "指挥者");tm.put("world", "世界２"); tm.put("javaee", "冠军");//遍历集合Set<String> set = tm.keySet();for(String key:set){String value = tm.get(key);System.out.println(key+"----"+value);}}
}

代码示例2：

TreeMap<Student,String>
键：Student
值：String
排序：学生年龄
定制排序：

class Student
{private String name;private int age;public Student(){super();}public Student(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;}@Overridepublic boolean equals(Object obj){if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Student other = (Student) obj;if (age != other.age)return false;if (name == null){if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}
}public class TreeMapDemo2
{public static void main(String[] args){//创建集合对象TreeMap<Student,String> tm = new TreeMap<Student,String>(new Comparator<Student>(){@Overridepublic int compare(Student s1, Student s2){//主要条件，学生年龄int num = s1.getAge()-s2.getAge();//次要条件，学生姓名内容int num1 = num == 0 ? s1.getName().compareTo(s2.getName()):num;          return num1;}});//创建对象Student s1 = new Student("周星驰",51);Student s2 = new Student("刘德华",55);Student s3 = new Student("梁朝伟",55);Student s4 = new Student("刘嘉玲",50);Student s5 = new Student("刘嘉玲",50);//添加元素tm.put(s1, "12");tm.put(s2, "13");tm.put(s3, "14");tm.put(s4, "15");tm.put(s5, "16");//遍历Set<Student> set = tm.keySet();for(Student key:set){String value = tm.get(key);System.out.println(key.getAge()+"--"+key.getName()+"--"+value);}        }
}

代码示例2：

学生对象（String，String）都有对应的归宿地
key = String,value=String
按照学生的年龄进行升序排序并取出，按照学生的星星进行生序排序并取出

定制排序：

class Student
{private String name;private int age;public Student(){super();}public Student(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;}@Overridepublic boolean equals(Object obj){if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Student other = (Student) obj;if (age != other.age)return false;if (name == null){if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}
}
public class TreeMapTest
{public static void main(String[] args){//自定义比较器Comparator<Student> com = new  Comparator<Student>(){@Overridepublic int compare(Student o1, Student o2){int temp = o1.getAge()-o2.getAge();return temp==0?o1.getName().compareTo(o2.getName()):temp;}         };Map<Student,String> map = new TreeMap<Student,String>();map.put(new Student("xiaomiang",24),"北疆");map.put(new Student("hhsa",23),"上号");map.put(new Student("xifea",24),"南涧");map.put(new Student("xifea",24),"hfah");Set<Map.Entry<Student,String>> entrySet = map.entrySet();for(Map.Entry<Student,String> me:entrySet){Student key = me.getKey();String value = me.getValue();System.out.println(key.getName()+key.getAge()+"..."+value);}       }
}

代码示例3：

学生对象（String，String）都有对应的归宿地
key = String,value=String
按照学生的年龄进行升序排序并取出，按照学生的星星进行生序排序并取出
自然排序：

public class Student implements Comparable<Student>
{private String name;private int age;public Student(){super();}public Student(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;}@Overridepublic int hashCode(){final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj){if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Student other = (Student) obj;if (age != other.age)return false;if (name == null){if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic int compareTo(Student o){int temp = this.age-o.age;return temp==0?this.name.compareTo(o.name):temp;}
}
public class TreeMapTest
{public static void main(String[] args){Map<Student,String> map = new TreeMap<Student,String>();map.put(new Student("xiaomiang",24),"北疆");map.put(new Student("hhsa",23),"上号");map.put(new Student("xifea",24),"南涧");map.put(new Student("xifea",24),"hfah");Set<Map.Entry<Student,String>> entrySet = map.entrySet();for(Map.Entry<Student,String> me:entrySet){Student key = me.getKey();String value = me.getValue();System.out.println(key.getName()+key.getAge()+"..."+value);}     }
}

2.6 集合名称阅读技巧

前缀名时数据结构名，后缀名时所属体系名

ArrayList：数组结构，看到数组，查询快；看到list，可以重复，可以增删改查
LinkedList：链表结构，增删快
HashSet:哈希表，元素必须覆盖hashCode()和equals()，看到set,不保证有序
LinkedHashSet：链表加哈希表，可以实现有序，因为有链表
TreeSet:看到Tree，必须排序，两种比较方式，一种自然排序Comparable，一种自定义排序Comparator

【java】集合类-2相关推荐

Java 集合类详解
0.参考文献 http://blog.csdn.net/liulin_good/article/details/6213815 1.java集合类图 1.1 1.2 上述类图中,实线边框的是实现类,比 ...
java集合类深入分析之TreeMap/TreeSet篇
2019独角兽企业重金招聘Python工程师标准>>> 简介 TreeMap和TreeSet算是java集合类里面比较有难度的数据结构.和普通的HashMap不一样,普通的HashM ...
【JAVA集合类(大公司面试喜欢问的) 】
看了一些所谓大公司的JAVA面试问题,发现对于JAVA集合类的使用都比较看重似的,而自己在这方面还真的是所真甚少,抽空也学习学习吧. java.util包中包含了一系列重要的集合类,而对于集合类,主要 ...
Java集合类: Set、List、Map、Queue区别及应用
Java集合类基本概念在编程中,常常需要集中存放多个数据.从传统意义上讲,数组是我们的一个很好的选择,前提是我们事先已经明确知道我们将要保存的对象的数量.一旦在数组初始化时指定了这个数组长度,这个数 ...
Java 集合类图(转)
1.java集合类图 1.1 1.2 上述类图中,实线边框的是实现类,比如ArrayList,LinkedList,HashMap等,折线边框的是抽象类,比如AbstractCollection,Ab ...
java 多线程集合操作_多线程中使用Java集合类
Java集合类中,某个线程在 Collection 上进行迭代时,通常不允许另一个线性修改该 Collection.通常在这些情况下,迭代的结果是不确定的.如果检测到这种行为,一些迭代器实现(包括 J ...
java集合类详细概述
2019独角兽企业重金招聘Python工程师标准>>> Java集合类集合中存放的是对象的引用,而非对象本身 ,出于表达上的便利,简称为"集合中的对象". ...
多线程中使用Java集合类
Java集合类中,某个线程在 Collection 上进行迭代时,通常不允许另一个线性修改该 Collection.通常在这些情况下,迭代的结果是不确定的.如果检测到这种行为,一些迭代器实现(包括 J ...
java集合类（简介）
JAVA集合类(介绍) 在使用Java的时候,我们都会遇到使用集合(Collection)的时候,但是Java API提供了多种集合的实现,我在使用和面试的时候频频遇到这样的"抉择" ...
Java集合类学习总结
Java集合类学习总结这篇总结是基于之前博客内容的一个整理和回顾. 这里先简单地总结一下,更多详细内容请参考我的专栏:深入浅出Java核心技术 https://blog.csdn.net/colum ...

【java】集合类-2

文章目录

1. 泛型简介

1.1 泛型类

1.2 泛型方法

1.3 泛型接口

1.4 泛型通配符

2 Map集合简介

2.1 Map集合的方法

2.2 Map集合的遍历

2.3 HashMap集合

2.4 LinkedHashMap集合

2.5 TreeMap集合

2.6 集合名称阅读技巧

【java】集合类-2相关推荐

最新文章

热门文章

【java】 集合类-2

文章目录

1. 泛型简介

1.1 泛型类

1.2 泛型方法

1.3 泛型接口

1.4 泛型通配符

2 Map集合简介

2.1 Map集合的方法

2.2 Map集合的遍历

2.3 HashMap集合

2.4 LinkedHashMap集合

2.5 TreeMap集合

2.6 集合名称阅读技巧

【java】 集合类-2相关推荐

最新文章

热门文章

【java】集合类-2

【java】集合类-2相关推荐