前言

有人也称之为容器

高斯算法

跳转结构（链式结构）：单向链表；双向链表；循环链表（双向基础）；

优点：删除和插入元素效率高

缺点：查询元素效率低

集合

数组和集合都是用来对多个数据进行存储操作的，简称为容器

Collection接口（以ArrayList为实现类）

常用方法：

集合有一个特点：集合只能存放引用数据类型，不能存放基本数据类型
基本数据类型可以自动装箱，对应包装类

Arrays.asList（）

public class Test01 {public static void main(String[] args) {/*Collection接口的常用方法：* 增加：add(E e)；addAll(Collection<? extends E> c)* 删除：clear()；remove(Object o)* 修改：* 查看：iterator()遍历；size()* 判断：contains(Object o)；equals(Object o)；isEmpty() *///接口不能创建对象，利用他的实现类创建对象，多态写法Collection col=new ArrayList();//集合只能存放引用数据类型，不能存放基本数据类型//调用方法：//集合有一个特点：集合只能存放引用数据类型，不能存放基本数据类型//基本数据类型可以自动装箱，对应包装类col.add(18);col.add(12);col.add(11);col.add(17);System.out.println(col);//在这相当于调用了一个toString，调用的是实现类arraylist的toString，不能调用接口的List list = Arrays.asList(new Integer[]{11, 15, 3, 7,1});//asList：把传进去的东西转成arraylist类型col.addAll(list);//将另一个集合添加入col中System.out.println(col);/* col.clear();//清空集合System.out.println(col);*/System.out.println(col.size());System.out.println(col.isEmpty());boolean isRemove=col.remove(15);System.out.println(col);System.out.println(isRemove);//trueCollection col2=new ArrayList();col2.add(18);col2.add(12);col2.add(11);col2.add(17);Collection col3=new ArrayList();col3.add(18);col3.add(12);col3.add(11);col3.add(17);System.out.println(col2.equals(col3));//true,比较内容System.out.println(col2==col3);//地址一定不相等，falseSystem.out.println(col3.contains(17));//true}
}

集合的遍历（两种方式）

public class Test02 {public static void main(String[] args) {Collection col=new ArrayList();col.add(18);col.add(12);col.add(11);col.add(17);col.add("abc");col.add(9.8);col.add(true);//集合里可以放多种引用数据类型//对集合进行遍历//方式1：普通for循环/*for (int i = 0; i < col.size(); i++) {System.out.println();//没有方法可以实现通过索引获取元素；方式一失败}*///方式2：增强for循环for(Object o:col){//因为可以放多种引用数据类型，所以用object类型System.out.println(o);}System.out.println("----------------------");//方式3：迭代器 iterator()Iterator it=col.iterator();//iterator是一个迭代器while (it.hasNext()){System.out.println(it.next());//next（）方法将元素获取到，并且将“指针”下移}}
}

迭代器简易原理图

List接口

常用方法及遍历方式

public class TestList {public static void main(String[] args) {/*List接口的常用方法（特有的，collection里的他也可以用）：* 增加：add(int index, E element)* 删除：remove(int index)；remove(Object o)* 修改：set(int index, E element)* 查看：get(int index)* 判断： *///扩展的方法都与索引相关List list=new ArrayList();list.add(13);list.add(17);list.add(6);list.add(-1);list.add(2);list.add("abc");System.out.println(list);list.add(0,66);System.out.println(list);list.set(3,98);System.out.println(list);list.remove(2);//在集合中存入的是Integer类型时，调用remove方法调用的是：remove(int index)System.out.println(list);list.remove("abc");System.out.println(list);Object o = list.get(0);System.out.println(o);System.out.println("-------------");//List集合遍历//方式1：普通for循环for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}//方式2：增强for循环System.out.println("-------------");for(Object o1:list){System.out.println(o1);}//方式3：迭代器 iteratorSystem.out.println("-------------");Iterator it = list.iterator();while(it.hasNext()){System.out.println(it.next());}}
}

ArrayList实现类

具体方法见上，重要的是源码，源码类似StringBuilder

JDK1.7版本

JDK1.8版

底层依旧是Object类型数组；size：数组中有效长度

Vector实现类（与AL的区别）

泛型

2、没有泛型时，如何使用集合

public class Fanxing {public static void main(String[] args) {ArrayList al=new ArrayList();al.add(18);al.add(12);al.add(11);al.add(17);al.add("丽丽");for(Object o:al){System.out.println(o);}}
}

如果不使用泛型的话，有缺点：

一般在使用集合时，我们基本上存入的都是相同类型的数据------》便于管理；现在什么类型数据都可以存入集合，不方便

3、集合中使用泛型，在JDK1.5之后

public class Fanxing {public static void main(String[] args) {ArrayList<Integer> al=new ArrayList<Integer>();//加入泛型的优点：在编译时期就会对类型进行检查，不是泛型对应的类型就不可以添加入这个集合al.add(18);al.add(12);al.add(11);al.add(17);for(Integer i:al){System.out.println(i);}}
}

自定义泛型结构

泛型类，泛型接口

泛型类的实例化：

/*GenericTest就是一个普通类
GenericTest<A> 就是一个泛型类
<>里面就是一个参数类型，但是这个类型是什么呢？这个类型现在是不确定的，相当于一个占位
现在只确定这个类型一定是引用数据类型，而不是基本数据类型*/
public class GenericTest<E> {int age;String name;E sex;public void a(E n){}public void b(E[] m){}
}
class Test{public static void main(String[] args) {//GenericTest进行实例化//1.实例化的时候不指定泛型：如果实例化的时候不明确指定类的泛型，那么认为泛型为object类型GenericTest gt1=new GenericTest();gt1.a("abc");gt1.a(17);gt1.a(9.8);gt1.b(new String[]{"a","b","c"});//2.实例化时指定泛型----->推荐方式GenericTest<String> gt2=new GenericTest<>();gt2.sex="男";gt2.a("abc");gt2.b(new String[]{"a","b","c"});}
}

泛型类的继承情况：

1、父类指定泛型

class SubGenericTest extends GenericTest<Integer>{}
class Demo{public static void main(String[] args) {//指定父类泛型，那么子类就不需要指定泛型SubGenericTest sgt1=new SubGenericTest();sgt1.a(15);}
}

2、父类不指定泛型

如果父类不指定泛型，那么子类也会变成一个泛型类，那么这个 E 的类型可以在创建子类对象的时候确定

class SubGenericTest2<E> extends GenericTest<E>{}
class Demo2{public static void main(String[] args) {SubGenericTest2<String> sgt=new SubGenericTest2<>();sgt.a("abc");sgt.b(new String[]{"a","b","c"});sgt.sex="女";}
}

应用场合：

4、（1）泛型可以定义多个参数类型

public class TestG01<A,B,C> {A age;B name;C sex;public void a(A m,B n,C x){}public TestG01() {//构造器}
}

（2）泛型类的构造器的写法

（3）不同的泛型的引用类型不可以相互赋值

（4）泛型如果不指定，那么就会被擦除，泛型对应的类型时object类型(见上)

（5）泛型类中的静态方法不能使用类的泛型

（6）不能直接使用E[]的创建

泛型方法

/*
* 1.什么是泛型方法：不是带泛型的方法就是泛型方法
* 泛型方法要求：这个方法的泛型的参数类型要和当前的类的泛型无关
* 换个角度：
* 泛型方法对应的那个泛型参数类型 和 当前所在的这个类是否是泛型类，泛型是啥 无关
* 2.泛型方法定义时，前面要加上<T>原因：如果不加的话，会把T当作一种数据类型，没有T类型那么就会报错
* 3.T的类型是在调用方法时确定的
* 4. 泛型方法可否是静态方法？可以是静态方法，static的位置要和public放在一起*/
public class TestG02<E> {//他不是泛型方法，不能是静态方法public void a(E e){}//他是泛型方法public static <T> void b(T t){}
}
class  Demo3{public static void main(String[] args) {TestG02<String> t=new TestG02<>();t.a("b");t.b("a");t.b(12);}
}

泛型参数存在继承关系的情况

通配符

在没有通配符时

下面的a方法相当于方法的重复定义，报错

有通配符时：

public class TestG04 {public static void main(String[] args) {List<Object> l1=new ArrayList<>();List<String> l2=new ArrayList<>();List<Integer> l3=new ArrayList<>();List<?> l=null;l=l1;l=l2;l=l3;}
}

总结：A和B是子类父类关系，但是G< A > 和 G< B >不存在继承关系的，是并列关系

加入通配符？后，G< ？>就变成G< A >和 G< B >的父类

使用通配符：

        test00 t=new test00();t.a(new ArrayList<Object>());t.a(new ArrayList<String>());t.a(new ArrayList<Integer>());}}
class test00{public void a(List<?> list){//1.内部遍历时，用object即可，不用？for(Object a:list){System.out.println(a);}//2.数据的写入操作//list.add("abc");----->报错；不能随意的添加数据list.add(null);//3.读取 前面类型必须为object类型Object o = list.get(0);//读取不行；写入可以，但是前面必须时object类型}

泛型受限

public class Test {public static void main(String[] args) {//a，b，c三个集合之间不具备子类父类关系，是并列的关系List<Object> a=new ArrayList<>();List<Person> b=new ArrayList<>();List<Student> c=new ArrayList<>();/** 开始使用泛型受限：泛型的上限* List<? extends Person>相当于* List<? extends Person>是List<Person>的子类，是List<Person的子类>的子类*/List<? extends Person> list1=null;//list1=a;报错list1=b;list1=c;/** 开始使用泛型受限：泛型的下限* List<? super Person>相当于* List<? super Person>是List<Person>的父类，是List<Person的父类>的父类*/List<? super Person> list2=null;list2=a;list2=b;//list2=c;报错}
}

LinkedList实现类

linked list底层使用的是双向链表

public class TestLinkedList {public static void main(String[] args) {/*LinkedList常用方法（除去继承的）：* 增加：addFirst(E e)；addLast(E e)；offer(E e)；offerFirst(E e)；offerLast(E e)* 删除：poll()；pollFirst()；pollLast()；-----》JDK1.6以后新出的方法提高了代码的健壮性*      removeFirst()；removeLast()* 修改：* 查看：element()；getFirst()；getLast()；indexOf(Object o)；lastIndexOf(Object o)*      peek()；peekFirst()；peekLast()；-----》同理，可提高健壮性* 判断：*/LinkedList<String> ll=new LinkedList<>();ll.add("aaaaa");ll.add("bbbbbb");ll.add("ccccc");ll.add("eeeee");ll.add("bbbbb");System.out.println(ll);//LinkedList可以添加重复的元素ll.addFirst("sky");ll.addLast("YYY");System.out.println(ll);ll.offer("xidian");//添加元素在尾端ll.offerFirst("ww");ll.offerLast("pp");System.out.println(ll);ll.poll();//检索并删除头元素System.out.println(ll);ll.pollFirst();ll.pollLast();System.out.println(ll);ll.remove();System.out.println(ll);System.out.println(ll.indexOf("xidian"));//5ll.clear();ll.pollFirst();//即使集合为空，删除也不报错，输出nullSystem.out.println(ll);//ll.removeFirst();//集合为空后，删除报错Exception in thread "main" java.util.NoSuchElementException//System.out.println(ll.get(0));//集合为空，获取报错System.out.println(ll.peek());//输出null//集合的遍历System.out.println("--------------------");//1.普通for循环for (int i = 0; i <ll.size() ; i++) {System.out.println(ll.get(i));}//2.增强for循环System.out.println("--------------------");for(String s:ll){System.out.println(s);}//3.迭代器System.out.println("--------------------");Iterator<String> it = ll.iterator();while (it.hasNext()){System.out.println(it.next());}//另一种写法//这种方式好，可以节省内存，it1在这个循环结束后就可以释放内存；it需要在整个方法结束后才能释放System.out.println("--------------------");for(Iterator<String> it1 = ll.iterator();it1.hasNext();){System.out.println(it1.next());}}
}

简要原理图：

debug验证数据添加成功：

模拟linked list源码

add，get(index)，getsize

List下面的都可以通过索引得到，collection不可以

public class MyLinkedList {//链中一定有一个首节点，一个尾节点Node first;Node last;//计数器int count=0;//构造器public MyLinkedList() {}//添加元素addpublic void add(Object o){if(first==null){//如果是第一个元素//将添加的元素封装为一个node对象Node n=new Node();n.setPre(null);n.setObj(o);n.setNext(null);//当前链中第一个节点变为nfirst=n;//当前链中最后一个节点也为nlast=n;}else{//已经不是第一个节点了Node n=new Node();n.setPre(last);//n的上一个节点一定是当前链中的最后一个节点lastn.setObj(o);n.setNext(null);//当前链中的最后一个节点的下一个元素要指向nlast.setNext(n);//将最后一个节点变为nlast=n;}//链中元素数量加一count++;}//集合中元素的数量public int getSize(){return count;}//通过下标得到元素public Object get(int index){//获取链表的头元素Node n=first;//一路next得到想要的元素for (int i = 0; i <index ; i++) {n=n.getNext();}return n.getObj();}
}
class Test{public static void main(String[] args) {MyLinkedList mll=new MyLinkedList();mll.add("aa");mll.add("bb");mll.add("cc");System.out.println(mll.getSize());System.out.println(mll.get(2));Node n=new Node();n.setObj("aa");System.out.println(n);}
}

public class Node {//节点类//三个属性//上一个元素的地址：private Node pre;//当前存入的元素：private Object obj;//下一个元素的地址private Node next;//当前元素的地址public Node getPre() {return pre;}public void setPre(Node pre) {this.pre = pre;}public Object getObj() {return obj;}public void setObj(Object obj) {this.obj = obj;}public Node getNext() {return next;}public void setNext(Node next) {this.next = next;}@Overridepublic String toString() {return "Node{" +"pre=" + pre +", obj=" + obj +", next=" + next +'}';}
}

linkedlist看源码

public class LinkedList<E>{//E是泛型，具体的类型在实例化的时候才会最终确定transient int size = 0;//集合中元素的数量private static class Node<E> {//内部类E item;//当前元素Node<E> next;//下一个元素地址Node<E> prev;//上一个元素地址Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}}transient Node<E> first;//头节点transient Node<E> last;//尾节点//空构造器public LinkedList() {}//添加元素public boolean add(E e) {linkLast(e);return true;}//添加的元素evoid linkLast(E e) {final Node<E> l = last;//将链表中的last节点给l，如果是第一个元素的话l为nullfinal Node<E> newNode = new Node<>(l, e, null);//将元素封装成一个具体的node对象//将链表的last节点指向新的创建的对象last = newNode;if (l == null)//如果添加的是第一个节点first = newNode;//将链表的first指向为新节点else//添加的不是第一个节点l.next = newNode;size++;modCount++;}//获取集合中元素数量public int size() {return size;}//通过索引得到元素public E get(int index) {checkElementIndex(index);//健壮性考虑return node(index).item;}Node<E> node(int index) {if (index < (size >> 1)) {//如果index在链表前半段，那么从前往后找，右移一位相当于除2Node<E> x = first;for (int i = 0; i < index; i++)x = x.next;return x;} else {//如果index在链表后半段，那么从后往前找Node<E> x = last;for (int i = size - 1; i > index; i--)x = x.prev;return x;}}
}

迭代器

用接口接他的具体实现类，多态的一种形式

面试题：iterator(),Iterator,Iterable关系

hasNext()；next()的具体实现

增强for循环的底层也是用迭代器实现的；可以通过debug验证

ListIterator迭代器

public class Test03 {public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();list.add("aa");list.add("bb");list.add("cc");list.add("dd");list.add("ee");//在"cc"之后添加字符串”kk"Iterator<String> it=list.iterator();while (it.hasNext()){if("cc".equals(it.next())){//Exception in thread "main" java.util.ConcurrentModificationException并发修改异常list.add("kk");}}}
}

发现报错：并发修改异常

出错原因：迭代器和list同时对集合进行操作

解决办法：事情让一个迭代器做-----》引入新的迭代器listIterator

public class Test03 {public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();list.add("aa");list.add("bb");list.add("cc");list.add("dd");list.add("ee");ListIterator<String> it =list.listIterator();while (it.hasNext()){if("cc".equals(it.next())){it.add("kk");//这里是迭代器添加，不是list添加}}System.out.println(list);it.hasPrevious();//看上面有没有元素System.out.println(it.hasNext());//falseSystem.out.println(it.hasPrevious());//true//逆向遍历while(it.hasPrevious()){System.out.println(it.previous());}System.out.println(it.hasNext());//trueSystem.out.println(it.hasPrevious());//false}
}

Set接口

List里有跟索引相关的方法，而Set里没有与索引相关的方法

HashSet实现类

1、放入Integer类型、String类型

public class TestHashSet {public static void main(String[] args) {//创建一个hashset集合HashSet<Integer> hs=new HashSet<>();System.out.println(hs.add(19));//true，放进去了hs.add(5);hs.add(20);System.out.println(hs.add(19));//false，没有放进去hs.add(41);hs.add(0);System.out.println(hs.size());//5；唯一，无序System.out.println(hs);//[0, 19, 20, 5, 41]HashSet<String> hss=new HashSet<>();System.out.println(hss.add("aaa"));//truehss.add("bbb");System.out.println(hss.add("aaa"));//falsehss.add("hhh");hss.add("ccc");System.out.println(hss.size());//4System.out.println(hss);//[aaa, ccc, bbb, hhh]}
}

2、放入自定义的数据类型

public class Student {int age;String name;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Student{" +"age=" + age +", name='" + name + '\'' +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age &&name.equals(student.name);}@Overridepublic int hashCode() {return Objects.hash(age, name);}public Student() {}public Student(int age, String name) {this.age = age;this.name = name;}
}

public class TestStudent {public static void main(String[] args) {HashSet<Student> hs=new HashSet<>();hs.add(new Student(19,"sky"));hs.add(new Student(20,"yhm"));hs.add(new Student(28,"lsj"));hs.add(new Student(19,"sky"));hs.add(new Student(30,"xn"));System.out.println(hs.size());//5System.out.println(hs);//[Student{age=28, name='lsj'}, Student{age=30, name='xn'}, Student{age=20, name='yhm'}, Student{age=19, name='sky'}, Student{age=19, name='sky'}]//重写之后输出//4//[Student{age=28, name='lsj'}, Student{age=30, name='xn'}, Student{age=20, name='yhm'}, Student{age=19, name='sky'}]}
}

上面自定义的类型不满足唯一，无序的特点

原因：没重写hashcode和equals方法

HashSet简要原理图：

后面会有答案

LinkedHashSet实现类

LinkedHashSet 使HashSet 变为唯一，有序；这个顺序是按照输入的顺序进行输出

public class TestLinkedHashSet {public static void main(String[] args) {//创建一个linkedhashset集合LinkedHashSet<Integer> lhs=new LinkedHashSet<>();lhs.add(19);lhs.add(5);lhs.add(20);lhs.add(19);lhs.add(41);lhs.add(0);System.out.println(hs.size());//5System.out.println(hs);//[19, 5, 20, 41, 0]；按输入顺序放入

按照输入顺序进行输出是如何做到的？

LinkedHashSet简要底层原理：

在底层数组上多加了一个链表：如：19—》6—》17----》11------》3这样就得到了一个有序的结构；便于遍历

比较器的使用

内部比较器

内部比较器：是指实现了Comparable接口，重写了compareTo方法，在类的内部进行比较

比较的思路：将比较的数据做差，然后返回一个int类型的数据，将这个int类型的数值按照 =0 >0 <0输出

public class Test01 {public static void main(String[] args) {//int比较int a=10;int b=20;System.out.println(a-b);// =0；>0；<0//string比较//string类重写了compareTo方法String s1="A";String s2="B";System.out.println(s1.compareTo(s2));//-1//double比较double d1=9.8;double d2=9.2;System.out.println(((Double)d1).compareTo((Double)d2));//1}
}

String类实现了Comparable接口，这个接口中有一个抽象方法compareTo，String类中重写了这个方法

比较自定义的数据类型：自己按照相比较的东西重写compareTo方法

外部比较器

返回int类型值

public class Student implements Comparable<Student>{private int age;private double height;private String name;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public double getHeight() {return height;}public void setHeight(double height) {this.height = height;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Student(int age, double height, String name) {this.age = age;this.height = height;this.name = name;}@Overridepublic String toString() {return "Student{" +"age=" + age +", height=" + height +", name='" + name + '\'' +'}';}@Overridepublic int compareTo(Student o) {return this.getAge()-o.getAge();}//内部比较器
}
//外部比较器
class Bijiao01 implements Comparator<Student> {@Overridepublic int compare(Student o1, Student o2) {//比较年龄return o1.getAge()-o2.getAge();}
}
class Bijiao02 implements Comparator<Student> {@Overridepublic int compare(Student o1, Student o2) {//比较姓名return o1.getName().compareTo(o2.getName());}
}

public class Test {public static void main(String[] args) {Student s1=new Student(11,160.6,"yhm");Student s2=new Student(18,165.6,"sky");//获取外部比较器Comparator bj=new Bijiao01();//想换比较方式的时候换这里就行，多态System.out.println(bj.compare(s1, s2));}
}

外部比较器和内部比较器谁好？

答：外部比较器；利用了多态，扩展性好

TreeSet实现类

特点：唯一，无序（没有按照输入顺序进行输出），有序（按照升序进行遍历）

1.存入Integer类型数据：底层用的是内部比较器

public class TestTreeSet {public static void main(String[] args) {TreeSet<Integer> ts=new TreeSet<>();ts.add(12);ts.add(3);ts.add(7);ts.add(9);ts.add(12);ts.add(16);System.out.println(ts.size());//5;唯一，有序且升序System.out.println(ts);//[3, 7, 9, 12, 16]}
}

TreeSet原理：底层：二叉树

2、存入string类型数据，底层也是利用内部比较器

public class TestString {public static void main(String[] args) {TreeSet<String > ts=new TreeSet<>();ts.add("olili");ts.add("blili");ts.add("alili");ts.add("slili");ts.add("alili");ts.add("zlili");System.out.println(ts.size());//5System.out.println(ts);//[alili, blili, olili, slili, zlili]}
}

3、存入自定义的数据类型；

利用内部比较器：自己定义比较器就行；如上面的Student类

自定义的数据类型如何使用外部比较器呢？

没有内部比较器的类，在创建treeset对象时；报错

public class TestS {public static void main(String[] args) {//写法一//利用外部比较器，必须自己指定Comparator<Student> com=new Bijiao02();//见上面外部比较器TreeSet<Student> tss=new TreeSet<>(com);//把比较器参数传过来；一旦指定了外部比较器，那么就会按照外部比较器进行比较tss.add(new Student(19,169,"sky"));tss.add(new Student(15,169,"sky"));tss.add(new Student(23,169,"sky"));tss.add(new Student(7,169,"zhy"));tss.add(new Student(12,169,"shy"));tss.add(new Student(5,169,"lsj"));tss.add(new Student(36,169,"yhm"));System.out.println(tss.size());System.out.println(tss);
//5
//[Student{age=5, height=169.0, name='lsj'}, Student{age=12, height=169.0, name='shy'}, Student{age=19, height=169.0, name='sky'}, Student{age=36, height=169.0, name='yhm'}, Student{age=7, height=169.0, name='zhy'}]}
}

实际开发中利用外部比较器多，因为扩展性好（多态）

public class TestS {public static void main(String[] args) {//利用外部比较器，必须自己指定//写法二Comparator<Student> com=new Comparator<Student>() {//匿名内部类的写法@Overridepublic int compare(Student o1, Student o2) {return o1.getName().compareTo(o2.getName());}};TreeSet<Student> tss=new TreeSet<>(com);//把比较器参数传过来；一旦指定了外部比较器，那么就会按照外部比较器进行比较//写法三TreeSet<Student> tss=new TreeSet<>(new Comparator<Student>() {//匿名内部类的写法@Overridepublic int compare(Student o1, Student o2) {return o1.getName().compareTo(o2.getName());}});}
}

treeset在进行遍历的时候如何得到升序的结果？

二叉树中序遍历

chapter11集合(1)相关推荐

chapter11集合(2)
Map接口键值对<key,value> Interface Map<K,V> 参数类型 K - 由此地图维护的键的类型 V - 映射值的类型 public class Tes ...
do还是doing imagine加to_中学必背英语短语集合：54个doing动名词的固定搭配
中学必背英语短语集合:54个doing动名词的固定搭配mp.weixin.qq.com doing动名词是中小学英语教学中的重要内容.在小学的时候老师大概会把doing解释为一般进行时,但层级越往上 ...
Redis 笔记（07）— sorted set 类型（添加、删除有序集合元素、获取分数范围内成员、按score排序、返回集合元素个数）
zset 可能是 Redis 提供的最为特色的数据结构,一方面它是一个 set,保证了内部 value 的唯一性,另一方面它可以给每个 value 赋予一个 score,代表这个 value 的排序权 ...
Redis 笔记（06）— set 类型（向集合添加元素、获取集合元素个数、判断集合中是否包含某个元素、删除给定元素、返回集合中所有元素、计算集合的交集、并集、差集）
Redis 的 set 集合内部的键值对是无序的唯一的.它的内部实现相当于一个特殊的字典,字典中所有的 value 都是一个值 NULL .当集合中最后一个元素移除之后,数据结构自动删除,内存被回收. ...
【C#】集合_哈希表_字典_泛型_文件
数组能做到:存放同种类型数据,且数据个数确定 object类型的数组能满足:放各种类型的数据,确定放多少个,但是随意插入元素,数组做不到集合能做到:存放各种数据类型,且不确定存放多少个,能做到随意插 ...
java集合中对象某属性比较排序
TreeSet:它可以给Set集合中的元素进行指定方式的排序. 保证元素唯一性的方式:通过比较的结果是否为0. 底层数据结构是:二叉树. 排序的第一种方式: 让元素自身具备比较性.只要让元素实现Com ...
程序员应该吃透的集合List
一:先看看集合框架接口图 (图片来源于网络) 从图中可以看到List实现了Collection接口. 二:Collection接口是什么? 在java类库中,Collection接口是集合类的基本接口 ...
Java集合详解之Map
一.首先看看集合框架体系图从图中可以看到,Map接口扩展了Iterator接口,关于Iterator接口详解请移步:Iterator接口详解二.Map是什么? Map<k,v>使用键值 ...
第一个python程序：定义，列表，元组，集合，求并集交集，键和值，运算符，缩进
''' 来源:天善智能韦玮老师课堂笔记 ''' print("定义") a = 6 # python里无需定义 print("a=",a) a += 1 # + ...

chapter11集合(1)

前言

集合