java集合结构----集合框架以及背后的数据结构
2.选择排序和冒泡排序的原理和区别:
1.Collection常见的方法实例
1)咱们的JAVA集合框架是定义在java.util包底下的一组接口和实现类
2)实现Iterable接口的类可以通过for each来进行遍历我们的集合
3)实现list接口都属于线性结构，比如说顺序表，链表，队列，战
4)Queue:队列，它本身也是一个线性结构，有一种队列不是线性的，比如说优先级队列(没实现Dqueue接口)
(队尾进，队头出)
5)DeQueue:双端队列(两端都可以进出)
6)实现Set接口的类是不能重复的
7)sortSet实现了set接口，不仅仅可以放重复的元素，还可以在存放元素的时候进行排序咱们的treeset就继承了SortedSet这个类，但是HashSet就没有实现SortedSet这个类
8)LinkedList本身可以做双向链表，可以做普通的队列，还可以做双端队列，他实现了Queue和list接口
9)PriorityQueue实现了Queue接口
10)实现Map接口的类是不可以通过foreach来进行遍历，TreeMap和TreeSet底层都是红黑树，TreeMap拥有排序的功能，HashMap没有排序的功能
Collection的常用接口:
1)boolean add(E e)添加元素e放到集合里面
2)void clear()清除集合里面的所有元素,先通过循环的方式把每一个元素都置为空，再将我们的size变成0
3)boolean IsEmpty()判断集合里面是否没有任何元素
4)boolean remove(E e)如果元素e出现在集合里面，那么就删除一个
5)int size()返回集合中的元素个数
没有get方法，没有获取元素的方法
，指定集合类中放哪些元素的时候，一定要指定类型，<>里面不要用简单类型
Collection<Integer> collection=new ArrayList<>();//1添加某些元素collection.add(1);collection.add(2);collection.add(3);//2删除某个元素collection.remove(1);//注意这里面的clear是针对集合类里面的元素全部进行清空//3打印集合类里面的元素System.out.println(collection);//打印结果是2，3//4把集合类中的所有元素放到数组中Object[] arr1= collection.toArray();//5判断是否为空System.out.println(collection.isEmpty());//6获取到集合类里面的长度System.out.println(collection.size()); Map<String,String> map=new HashMap<>();map.put("及时雨","宋江");map.put("国民女神","高圆圆");Set<Map.Entry<String,String>> set=map.entrySet();//1)当我们调用这个方法之后,会把哈希表中的每一对key和value包装成一个整体,相当于把两个元素放到一个大盒子里面，变成一个元素//2)然后内存就会把每一个大盒子放到Set里面,这个大盒子就是Map.Entry(String,String)类型for(Map.Entry<String,String> sb:set){System.out.println(sb.getKey());System.out.println(sb.getValue());}Map的常用方法:
1)V get(object k)根据K查找对应的value
2)V getOrDefault(Object K,V defaultValue)根据K查找对应的V，查不到就用我们制定的默认值来进行代替
3) V put(K k,V v)存放键值对
4)boolean containsKey(Object K),boolean containsValue(Object V)判断是否存在Key和Value
2.简单类型和包装类(针对的是基本数据类型)
1)将简单的数据也是可以面向对象的，让整数与字符串之间的转换更加方便，只需要调用一个方法即可，就不需要自己写一个方法来进行实现，帮我们对数据进行处理，String不是一个包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean我们在对数据类型进行转换的时候
//1将字符串转化成整数String str="123";int a=Integer.valueOf(str);int b=Integer.parseInt(str);//2将整数转化成字符串String str1=Integer.toString(a);int与Integer的区别
1)类型不同:Integer是对象类型,int是基本数据类型，Integer是int的包装类
2)Integer的默认值是null,int的默认值是0，当new Integer()的时候实际上是生成一个指针指向对象，但是int直接储存数值；
3)Integer变量需要实例化之后才能使用，int则不需要。
4)Integer变量和int变量进行比较时，java会自动将Integer对象拆包装为int，然后进行比较，实际上就变为两个int变量比较。
5)Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值
6)包装类型可以用于泛型,但是简单类型是不可以的
2)装箱和拆箱
装箱/装包:将一个简单的数据类型转化成包装类型Integer.valueOf();
拆箱/拆包:将一个包装类型转化成简单的数据类型intValue();
//1.自动装箱装包,隐式Integer a=10;//看似是将一个简单类型转化成包装类型,本质上就是调用了Integer.valueOf方法//2.自动进行拆箱,拆包,隐式int b=a;//在这里面默认调用了Integer的intValue方法,自动进行拆包//1.下面都是装包,是显式的进行装包Integer t1=Integer.valueOf(123);Integer t2=new Integer(123);Integer t1=(Integer)123;//2.下面是拆包,是显式的进行拆包int a=t1.intValue();double b=t1.doubleValue();float c=t1.floatValue();int f=(int)t1;
下面是隐式的进行装包和拆包1)Integer a=123;//123本来是一个简单数据类型,但是最终变成了包装类，这个过程就是装箱
//上面的过程中底层默认调用了Integer.valueOf()方法2)int b=a;//a本来是一个包装类,就将一个包装类型转化成简单的数据类型,拆箱
//他的底层默认调用了intValue()方法
_________________________________________________________________________________________Integer a=10;System.out.println(a.value);
这会访问失败,因为value字段是默认是Integer包装类中的用private修饰的字段
所以说简单数据类型在包装类中就是一个Value属性
下面是显示进行装包和拆包//显示进行装包Integer integer=new Integer(123);Integer s1=Integer.valueOf(123);//显示进行拆包int a=s1.intValue();double b=s1.doubleValue();
Integer a=123;Integer b=123;System.out.println(a==b);//trueInteger c=129;Integer d=129;System.out.println(c==d);//false上面都涉及了自动装包public static Integer valueOf(int i) { if(i>IntegerCache.low&&i<=IntegerCache.high)(low=-128,high=127){ return Integer.Cache[i+(-IntegerCache.low)](注意，这里面的Cache是一个数组)}return new Integer(i);//new 对象 }1)当我们传入的数据是在-128-127之间，会返回一个catche数组的值
当我们传入127的时候，返回的是Cache[255],此时128是最大的数据，此时得到的数组下标就是255；当我们传入-128的时候，返回的是Cache[0]
注意这个数组里面的范围下标是0-255；
Cache[0]=-128; Cache[1]=-127;.........Cache[255]=127
总结:当我们传入的数据在-128-127内,会先进行计算下标，再会返回数组里面所存放的值；返回的是数值；
掏出了这个数据范围之后,就会在堆上new 一个新的对象，返回的是一个对象，此时我们要进行比较的是引用；
Integer的比较方式:
1)==只能用于非Integer的值，在-127~128直接按照值的方式来进行比较，超过这个范围就不适用了，在valueOf方法里面，Integer的取值在-128~127之间，他会进行复用原来有的对象，否则就会直接在堆上面new Integer()对象出来
2)使用equals方法，在Integer中重写了equals方法:通过拆箱来进行比较
public boolean equals(Object obj) {if (obj instanceof Integer) {return value == ((Integer)obj).intValue();}return false;}3)Integer实现了Compareable接口，并且重写了里面的compareTo方法，取出Integer对象的value属性来进行比较:前一个数-后一个数
public int compareTo(Integer anotherInteger) {return compare(this.value, anotherInteger.value); } public static int compare(int x, int y) {return (x < y) ? -1 : ((x == y) ? 0 : 1); }4)直接进行运算:我们可以直接将两个值进行相减，来进行判断，如果说相减的值是0，那么说明他们相等
5)我们可以进行调用里面的intValue方法来进行比较:
Integer a=new Integer(100);Integer b=new Integer(100);System.out.println(a.intValue()==b.intValue());6)通过异或的方式来进行比较:不同为1，相同为0
3.泛型
问题:下面是一个简单的顺序表，我们在这里面实现的一个顺序表，是存放的数据类型只有int类型，这就会很不通用,如果我们想什么样的类型的数据都想要放进去,就要把这个数组的类型设置成Object类型
能不能啥样的类型都可以存放呢？
class MyArraylist{private int[] arr1;private int usedsize;public MyArraylist(){this.arr1=new int[10];}public void add(int pos,int val){this.arr1[pos]=val;}public int get(int pos){return this.arr1[pos];}}
改成下面的代码之后，还是发现有问题：
1)这个代码太通用了,什么样类型的数据都可以进行存放不能指定元素，下面的代码里面的元素既可以存放int，又可以存放String，完全就是一个大杂烩，能不能只让他存放整型或者是
字符串类型呢？
2)取出我们的Object顺序表中的元素，因为咱们返回的是Object类型，还需要进行强制类型转换，这是很麻烦的；
我们现在想要做到下面几件事：
1）能不能指定我这个顺序表的类型，只能存放一种数据类型？
2）指定类型之后，是不是就只能存放指定类型的数据呢？
3）取出数据之后，可不可以不进行数据类型转换？
static class MyArraylist{private Object[] arr1;private int usedsize;public MyArraylist(){this.arr1=new Object[10];}public void add(Object val){this.arr1[usedsize]=val;usedsize++;}public Object get(int pos){return this.arr1[pos];}}public static void main(String[] args) {MyArraylist list=new MyArraylist();list.add(1);list.add("hello");String ret=(String)list.get(1);}在指定类的后面写上<T>，它是代表当前的类是一个泛型类，此时的这个T就只是一个占位符而已，把类型参数化了，直接就是一个T类型的数组了，不能泛型化数组
private T[]=new T[10];--------private T[]=(T[])new Object[];创建数组最好用反射
泛型的意义:
1)存放数据的时候，在编译的时候会自动地对要放进去的类型进行检查，当取数据的时候，编译器会自动地对取出来的数据进行强制类型转换
2)泛型中<>里面的内容是不进行参与类型的组成的
3)泛型类型的参数，只能是包装类，而不能是简单类型
咱们内部的ArrayList使用泛型的时候也是new Object数组，但是他的get方法，把他的单个元素强转成(E)(array[index])，不是整体数组强转，而是单个类型强转成E类型
泛型是怎么进行编译的？范型只有上界，没有下界
toarray()将一个list数组转化成数组
javap -c 类名
反省是编译时期的一种机制
泛型这个概念只在编译时期起作用，在运行时期是没有泛型这个概念的;在编译时会被擦除为Object类型，编译器生成的字节码文件并不包含泛型的类型信息
一:public class MyArray<E extends Number>{ } 这表示E可以是Number或者是Number的子类 1)MyArray<Integer> l1;//这是正常的,因为Integer是Number的子类 2)MyArray<String> l2;//这是错误的,因为String并不是Integer的子类 二:没有指定边界,默认就是Object,比如说class MyArray<T>{}下面我们来写一个方法，来求数组中元素的最大值
class ALG<T>{public T GetMax(T[] array){T max=array[0];for(int i=1;i<array.length;i++){//这是引用类型的比较,max是T类型,array[i]也是引用类型,引用类型是不可以通过>=<来进行比较的if(array[i]>max){max=array[i];}}return max;}}既然是引用类型，我们就要重写Compareable接口，重写compareTo方法来比较两个引用类型，但是我们发现上述这个代码，compareTo方法点不出来，因为程序不知道你这个类是否继承了Compareable接口？重写了CompareTo方法
class ALG<T extends Comparable<T>> 这种写法就表示此时这个T一定要实现Compareable接口,这是泛型的上界package Demo; class ALG<T extends Comparable<T>>{public T GetMax(T[] array){T max=array[0];for(int i=1;i<array.length;i++){//这是引用类型的比较,max是T类型,array[i]也是引用类型,引用类型是不可以通过>=<来进行比较的if(array[i].compareTo(max)>0){max=array[i];}}return max;} } public class TestData {public static void main(String[] args) {ALG<String> avg=new ALG<>();String[] strings={"abcd","abc","ab","a"};int[] array={1,3,2,45,67,87};String str= avg.GetMax(strings);System.out.println(str);} }1)这时候会出现一个问题，咱们每一次调用findmax都要newALG()这样的对象吗，才可以通过这个对象的实例来进行调用findmax这样的方法，就显得太麻烦了
2)这个时候我们加上static关键字，不就可以保证通过类名来进行调用了吗？如果加上了static关键字之后，这个静态方法是不依赖于对象的，咱们的这个T参数是在new ALG中的尖括号进行传参的
class ALG<T extends Comparable<T>>{public static<T extends Comparable<T>> T GetMax(T[] array){T max=array[0];for(int i=1;i<array.length;i++){//这是引用类型的比较,max是T类型,array[i]也是引用类型,引用类型是不可以通过>=<来进行比较的if(array[i].compareTo(max)>0){max=array[i];}}return max;}} 这个时候就不需要进行new对象了,这就是咱们的一个静态的泛型方法package Demo; class ALG{public static<T extends Comparable<T>> T GetMax(T[] array){T max=array[0];for(int i=1;i<array.length;i++){//这是引用类型的比较,max是T类型,array[i]也是引用类型,引用类型是不可以通过>=<来进行比较的if(array[i].compareTo(max)>0){max=array[i];}}return max;}} public class TestData {public static void main(String[] args) {Integer[] array={12,34,34,45,67};int max=ALG.<Integer>GetMax(array);}}理论上来说ArrayList<Integer> 不是ArrayList<Number>的父亲类型
ArrayList<Number>也不是ArrayList<Integer>的子类
通配符:
通配符是无法解决泛型无法谐变的问题的，谐变指的是Student如果是Person的子类，那么List<Student>也应该是List<Person>的子类，但是泛型是不支持这样的父子类关系的
1)泛型T是确定的类型，一旦你要是传了，我就定下来了，但是通配符可以说是更为灵活或者不稳定，更多地用于扩充参数的范围
2)或者我们可以这么理解:泛型T就像是一个变量，等待着你可以传输一个具体的类型，而通配符是一种规定，规定你可以传哪些参数
class AVL{public static<T> void print1(ArrayList<T> list){for(T x:list){//编译器一定知道当前传递过来的是一个T类型的数据System.out.println(x);}}public static void print2(ArrayList<?> list){for(Object x:list)//编译器不知道？是啥类型,具体的类型我不知道{System.out.println(x);}} }通配符的上界:
<? extends 上界> <? extends Number>//可传入的参数类型是Number或者是Number的子类 举例: public static void printAll(ArrayList<? extends Number > list>{} //上面表示可以传入的类型是Number的子类的任意类型的ArrayList 下面都是正确的: printAll(new ArrayList<Integer>()); printAll(new ArrayList<Double>()); printAll(new ArrayList<Number>()); 下面搜是错误的 printAll(new ArrayList<String>()); printAll(new ArrayList<Object>());假设现在有下面的关系:
Animal
Cat extends Animal
Dog extends Animal
根据上面的关系，写一个代码，打印一个存储了Animal或者Animal子类的list
代码1:
public static void print(ArrayList<Animal> list>{}这样是不可以进行解决问题的，因为print的参数是List<Animal>，我们就不可以进行接收List<Cat> list
代码2:
public static<T extends Animal> void print3(List<T> list){for(T animal:list){System.out.println(animal);}}这时候T类型是Animal的子类或者是自己，该方法也是可以实现的，这里面的类型是一个确定的类型，编译器知道是什么类型
代码三:通配符来进行实现:
public static void print(List<? extends Animal> list> {for(Animal x:list){System.out.println(x);//编译器此时不知道这是调用谁的ToString方法 发生了向上转型,不知道这个类型具体是啥类型,反正指定了上界,编译器就认为你传递过来的类一定是Animal或者是Animal的子类,如果没有这个通配符上界Animal这里面就应该写成Object了} }1)总结:ArrayList<? extends Number>是ArrayList<Integer>或者ArrayList<Double>的父类类型
2)ArrayList<?>是ArrayList<? extends Number>的父亲类型
通配符的上介是不适合用于写入对象的:
ArrayList<Integer> list1=new ArrayList<>();list1.add(1);list1.add(2);ArrayList<Double> list2=new ArrayList<>();List<?extends Number> list=list1;//list.add(1,9);//这里面是不适合进行写入数据的,适合于读数据,如果你进行存放的话,即可以进行存放整数,也可以存放浮点数这是不可以的,因为最最终引用的只有一种类型//list.add(2,10.9);Number number= list.get(1);//正确//Integer s1=list.get(0);这样的写法是错误的,因为不知道里面具体存放的是哪一种类型,万一存放的是Double类型呢我们的通配符的上介适合读取数据，不适合写入数据，上面的list可以进行引用的对象有很多，编译器是无法确定你的具体的类型的，所以说编译器为了安全起见，此时只允许你进行读取
通配符的下界:
<? super 下界> <? super Integer>这是代表可以进行传入的实参的类型是Integer或者是Integer的父类类型假设有下面代码:
public static void printAll(ArrayList<? super Integer> list){ } //下面表示传入的实参都是Integer的父类的任意类型的ArrayList 下面的调用都是正确的: printAll(new ArrayList<Integer>()); printAll(new ArrayList<Number>()); printAll(new ArrayList<Object>()); 下面的调用是编译错误的: printAll(new ArrayList<String>); printAll(new ArrayList<Double>);咱们的ArrayList<? super Integer> 是ArrayList<Integer>的父类类型
ArrayList<?>是ArrayList<? super Integer>的父类类型
ArrayList<? super Person> list=new ArrayList<>(); //ArrayList<? super Person> list2=new ArrayList<Student>();这里面会出现报错,因为list2只能引用Person或者Person父类类型的list list.add(new Person());//添加元素的时候,只要添加的元素是Person或者是Person的子类就可以了 list.add(new Student()); Person person=list.get(0)//父类引用引用子类对象,应该是对的呀？？？？ Student s=list.get(0)//错误,因为Person的子类有很多,不一定就是Student Object s=list.get(1);//正确我们在进行添加元素的时候，我们知道list引用的对象肯定是Person或者是Person的父类的集合，此时我们可以确定此时能够储存的最小粒度比Person小就可以，你放的时候，放的都是Person或者Person的子类，但是你读取的时候，你能确定你读取的时候读取的是那一个子类吗？
关于异常的复习:
1、运行时异常
(1)运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。当出现RuntimeException的时候，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。
出现运行时异常后，如果没有捕获处理这个异常（即没有catch），系统会把异常一直往上层抛，一直到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被catch块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。
如果不想终止，则必须捕获所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。2、非运行时异常
(2)非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。如IOException、SQLException等以及用户自定义的Exception异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch并处理，否则程序就不能编译通过。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常,也可以用throws声明异常
RuntimeException体系包括错误的类型转换，数组越界访问以及尝试访问空指针，必须被try catch语句块捕获，这是错误的，可以直接由JVM处理1)Object类型是所有class类型的父亲，是根，数组当然也是一种class类型，因此Object[]和Test[]类型都是Object类型的子类型，对于Test[]类型和Object[]类型，二者同为数组类型，他们之间没有什么父子关系，而是平级的关系，所以数组之间是不可以进行强制类型转换的，String与String[]的父类都是Object类型
2)如果强制进行数组类型转换就会抛出ClassCastException异常
String[] s=new String[10];Object e=new String[10];Object t=new String("abc");import java.io.FileNotFoundException; import java.io.IOException; public class HelloWorld {public static void TestDemo(){System.out.println("执行这个方法");}public static void main(String[] args) {((HelloWorld)null).TestDemo();}public static void run(){try{//这里面做了一些事情} catch(FileNotFoundException e){System.out.println("发生文件找不到异常");}catch (IOException ex){System.out.println("发生了IOException");}catch (java.lang.Exception e){System.out.println("发生了异常");}}//这里面无论语句发生了什么异常,最终只能有一个catch语句快执行,他们是构成父子类关系的,只能抛出一个异常,只能捕获一个异常 }重写equals方法的时候为什么一定要重写hashcode?
1)equals方法和hashcode方法是Object中的两个基础方法，他们共同来协作判断两个对象是否相等，这样做的好处就是，效率更高，如果不重写，就会出现BUG
2)因为通过hashcode的值，我们就可以直接定位到一个数据的存储位置，而不需要一个一个的循环查找
3)hashcode也叫作散列码，他是由对象推导出的一个整数值，并且这个值包括任意整数，包括正数和负数，况且散列码是没有规律的，如果说x，y是两个不同的对象，那么x.hashcode()和y.hashcode()基本上不会相同(也有可能是相同的)，Object中的hashcode是只是根据地址只生成的，对比两个对象的引用地址
String str=new String("abc");String str2=str;//重写了hashcode方法String str3=str2;System.out.println(str.hashCode());System.out.println(str2.hashCode());System.out.println(str3.hashCode()); 他们的地址值都是相同的package Demo; class Task{public String name;public int age;public Task(String name,int age){this.age=age;this.name=name;} } public class DemoKail{public static void main(String[] args) {Task task1=new Task("李佳伟",19);Task task2=task1;System.out.println(task1.hashCode());System.out.println(task2.hashCode());Task task3=new Task("李佳伟",19);System.out.println(task3.hashCode());} } 打印结果:644117698 644117698 1872034366但是重写hashcode之后，这三个值就相同了
总结:
1)当我们使用HashMap，HashSet集合的时候，会进行计算对象在散列表中的位置
2)如果我们只重写hashcode方法，不重写equals方法，两个相同的对象就会存储到相同的位置，但是此时equals方法没有重写，两个对象就被判定成不相等
3)如果我们只重写equals方法，而没有重写hashcode方法，像hashMap等集合类的判断逻辑是先进行判断hash之是否相等，在进行判断对象值是否相等，如果没有重写hashcode，两个相等的对象可能就被放在散列表不同的位置，根本就没有equals判断的机会
4)如果是我们自己自定义的类，也不用这些集合类，就不会调用hashcode方法，只需要重写equals方法即可，此时也没有必要重写equals方法了
如果在HashSet中存储重写的自定义对象的时候，就会无法实现去重:
package Demo;import java.util.HashSet; import java.util.Iterator; import java.util.Objects;class Task{public String name;public int age;public Task(String name,int age){this.age=age;this.name=name;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Task task = (Task) o;return age == task.age && Objects.equals(name, task.name);}// @Override // public int hashCode() { // return Objects.hash(name, age); // }@Overridepublic String toString() {return "Task{" +"name='" + name + '\'' +", age=" + age +'}';} } public class DemoKail{public static void main(String[] args) {Task task1=new Task("李佳伟",18);Task task2=new Task("李佳伟",18);Task task3=new Task("李佳伟",18);HashSet<Task> set=new HashSet<>();set.add(task1);set.add(task2);set.add(task3);Iterator<Task> iterable=set.iterator();while(iterable.hasNext()){Task task=iterable.next();System.out.println(task);}} }
java集合结构----集合框架以及背后的数据结构相关推荐
- 集合框架及背后的数据结构、Collection，Map、ArrayList的使用
一.类和接口总览 二.Collection 接口 1.Collection 常用方法 2.Map 接口 三.预备知识-泛型(Generic) 泛型是怎么编译的? 四.预备知识-包装类(Wrapper ...
- 集合框架及背后的数据结构
一. Java 集合框架 Java 集合框架 Java Collection Framework ,又被称为容器 container ,是定义在 java.util 包下的一组接口 interface ...
- java 中的数据元素的定义_Java数据结构和算法的基础概念
一.基本的概念 1.数据 是客观描述事物的符号,是计算机中操作的对象,是能被计算机识别.并输入给计算机处理的集合 2.数据元素 是组成数据的,有一定意义的基本单位. ...
- java集合框架容器 java框架层级 继承图结构 集合框架的抽象类 集合框架主要实现类...
本文关键词: java集合框架 框架设计理念 容器 继承层级结构 继承图 集合框架中的抽象类 主要的实现类 实现类特性 集合框架分类 集合框架并发包 并发实现类 什么是容器? 由一个或多个确 ...
- java面向对象编程集合边框_java 面向对象编程-- 第15章 集合框架
1. 集合特点:元素类型不同.集合长度可变.空间不固定 2. java中对一些数据结构和算法进行了封装即集合.集合也是一种对象,用于存储.检索.操作和传输对象. 3. JCF(Java Coll ...
- Thinking in java基础之集合框架
Thinking in java基础之集合框架 大家都知道我的习惯,先上图说话. 集合简介(容器) 把具有相同性质的一类东西,汇聚成一个整体,就可以称为集合,例如这里有20个苹果,我们把每一个苹果当成 ...
- java把map值放入vector_Thinking in java基础之集合框架
Thinking in java基础之集合框架 大家都知道我的习惯,先上图说话. 集合简介(容器) 把具有相同性质的一类东西,汇聚成一个整体,就可以称为集合,例如这里有20个苹果,我们把每一个苹果当成 ...
- java学习日记 集合框架
集合框架 有两大接口 一个是 Collection (类集 )与Map (映射): collection 下有两大接口 一个是List (列表) 另一个是Set(集合) List (列表):Arr ...
- 【java学习】集合框架
1,常用map AbstractMap 的成员变量:transient, volatile修饰 transient volatile Set<K> keySet;//keySet, 保存 ...
最新文章
- 机器学习PAI产品架构
- MIT新研究给量子计算机「泼冷水」：自然界辐射会干扰它，需要研究新对策 | Nature...
- LetCode 15 三数之和
- 西数硬盘刷新固件_玩4k如何选硬盘？究竟那些硬盘适合你
- redis 本地安装
- eclipse 安装vim插件
- ccs6 linux安装教程,【图片】【吧主帖】在LINUX（ubuntu）系统下装CCSv6方法（原创）【dsp吧】_百度贴吧...
- mysql_crud
- 面向中后台复杂场景的低代码实践思路
- 关于make_work_guard猜想
- eclipse中server name选项变灰
- 比Magic Leap快一步，HoloLamp做到了裸眼观看全息图
- 注意力机制可解释吗？这篇ACL 2019论文说……
- IOS开发之Bug--关于UIImageView的使用
- Axure 免费UI元件库
- 为基因序列片段在NCBI的GenBank数据库申请登录号
- Stack和Queue：后进先出和先进先出和Java 实现后进先出(LIFO)及Stac和Java集合类: Set、List、Map、Queue使用场景梳理 - .Little Hann
- 黑马程序员Java零基础视频教程(2022最新Java）B站视频学习笔记-Day13-面向对象进阶01
- 2021年五一赛A题-疫苗生产优化问题
- 2-6_Cleaning_Data