Java第十一章集合

已于 2022-07-28 08:43:49 修改
阅读量177 收藏
点赞数
文章标签： java 开发语言 后端
于 2022-02-24 09:15:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43708627/article/details/121773541
版权

集合大致分为四个体系：Set、List、Queue、Map

  • Set：包括无序，不可重复的集合，主要包括HashSet实现类、TreeSet实现类、LinkedHashSet实现类
  • List：有序可重复的集合，主要包括ArrayList、LinkedList实现类
  • Map：代表有映射关系的集合，主要包括HashMap、TreeMap实现类
  • Queue：一堆队列集合实现

主要由两个接口Collection和Map实现

1.Collection接口

collection接口中的实现类的对象添加的数据都是object类型，都是对象 ，因此对象都有其所在类，不可以添加基本数据类型，添加的基本数据类型也都是装箱之后的包装类

单列集合，用来存储一个一个的对象
Collection接口中有List接口和Set接口。
List接口：存储有序的、可重复的数据
Set接口：存储无序的、不可重复的数据
因此set和list接口的实现类可以使用collection接口中的方法，collection接口（父接口）的方法，在子接口以及实现类中都可以使用

  • 1.add(Object obj) 添加元素；addAll(Collection coll)
  • 2.int size() 获取有效元素的个数
  • 3.void clear() 清空集合
  • 4.boolean isEmpty() 是否是空集合
  • 5.boolean contains(Object obj) 是否包含某个元素，是通过元素的equals方法来判断是否是同一个对象；boolean containsAll(Collection c)：也是调用元素的equals方法来比较，拿两个集合的元素挨个比较
  • 6.boolean remove()；removeAll
  • 7.retrainAll(Collection coll1) 求交集，获取当前集合和coll1集合的交集，并返回给当前集合
  • 8.equals(Object obj) ：调用当前对象所在类的equals方法
  • 9.hashcode()：返回当前对象的哈希值
  • 10.coll.toArray()返回的是object类型，把集合转为数组
  • 11.Arrays.aslist(new String[]{})，调用Arrays类的静态方法asList，把数组转为集合

add用法: collection接口中的实现类的对象添加的数据都是object类型，都是对象 ，因此对象都有其所在类，不可以添加基本数据类型，添加的基本数据类型也都是装箱之后的包装类。
contains用法: 要求collect接口实现类的对象中添加数据obj时候，要求obj所在类要重写equals方法。

Collection coll = new ArrayList();
//1.add
coll.add(new String("TOM");
//2.contains
coll.contains(new String("TOM"))//true，因为String类中重写了equals方法
coll.add(new Person("jerry",10));
coll.contains(new Person("jerry",10));
//如果没有重写equals方法，调用的就是父类Object的equals，Object中的equals就是==，也就是会比较地址值，因此输出false
//因此，需要定义的Person类重写equals方法，输出true
Collection coll1 = Arrays.asList(123,4567);
//3.containsAll
sout(coll.containsAll(coll1));//判断coll1中的所有元素是否都在coll中
//4.remove(Object obj)
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
//remove调用equals方法
coll.remove(1234);
coll.remove(123);
//5.retrainAll(Collection coll1):交集，获取当前集合和coll1集合的交集，并返回给当前集合，没有返回值，直接修改原数组
//6.equals(Object obj):要想返回true，当前集合和形参集合的元素都相同，区分array集合和hash集合，注意顺序
//7.hashcode
//8.集合——数组
Object[] arr = coll.toArray();
//9.数组——集合
List<String> list = Arrays.asList(new String[]{"AA","BB","CC"});
//注意
List arr1 = Arrays.asList(new int[]{1,2})//识别为1个元素，打印出来是地址
List arr1 = Arrays.asList(new Integer[]{1,2})//识别为2个元素
//iterator():返回Iterator接口的实例，用于遍历集合元素

集合元素的遍历Iterator

1.内部的方法：hasNext()和next()方法
2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
3.内部定义了remove()，可以在遍历的时候，删除集合中的元素。此方法不同于collection中的remove

while(iterator.hasNext()){
  sout(iterator.next());
}

在这里插入图片描述
注意⚠️

  • iterator本身不是容器，只是迭代器，操作仍然是在coll集合上，集合是个容器
  • 指针先下移，再返回
  • 错误写法一：跳着输出，并且会报异常
Iterator iterator = coll.iterator();
while((iterator.next())!=null){
   sout(iterator.next());
}
  • 错误写法二：死循环，一直输出第一个元素，因为每调一次iterator，都会返回一个新的迭代器对象，新的迭代器对象指向第一个元素
while(coll.iterator().hasNext()){
    sout(coll.iterator().next());
}

for each循环

用于遍历集合和数组

//for(集合元素类型 局部变量 ：集合对象)
//内部仍然调用了迭代器
for(Object obj:coll){
  sout(obj);
}

String []arr = new String[]{"mm","mm","mm"};
//方式一：普通for赋值，输出是gg
fot(int i=0;i<arr.length;i++){
   arr[i] = "gg";
}
//方式二：for each增强for循环，输出是gg
for(String s:arr){
  s="gg";
}
//相当于把arr重新赋值给s，因此arr的值不变，s的值为gg
for(int i =0;i<arr.length;i++){
  sout(arr[i]);
}

集合和数组存储数据： 集合和数组都是对多个数据进行存储操作的结构，简称Java容器
不同之处
1.数组：

  • 一旦初始化之后，长度就确定了
  • 数组一旦定义好，元素的类型也确定了
String[] arr;
int [] arr1;
Object [] arr2;
  • 数组的弊端：提供的方法有限，对于添加、删除、插入操作不便；对于无序、不可重复的需求不能满足；获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用

2.集合的优点

List接口

存储有序的、可重复的数据
动态数据，替换原有的数组
常用的实现类有：ArrayList,LinkedList,Vector
三者的异同？

  • 相同点：都实现了List接口，存储数据特点相同
  • 不同点
    ArrayList：主要实现类，线程不安全，效率高，底层使用Object[] elementData 数组存储（String底层使用char[] value 型数组存储）
    LinkedList：对于频繁的插入、删除操作，使用此类效率高，底层使用双向链表存储
    Vector：古老实现类，线程安全的，效率低，底层使用Object[]数组存储

源码分析

  • 1.ArrayList(jdk7)
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0]=new Integer(123);
……
list.add(11);//当添加的元素个数，如果此次的添加导致底层elementData数组容量不够，则扩容。默认扩容为原来数组长度的1.5倍，同时将原有数组中的数据复制到新的数组中

结论：开发中使用带参的构造器ArrayList list = new ArrayList(int capacity)

  • 1.1ArrayList(jdk8)
ArrayList list = new ArrayList();//底层Object[]elementData初始化为{},并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData[0]

小结：jdk7中ArrayList对象的创建类似于单例的饿汉式，jdk8中ArrayList对象的创建类似于单例的懒汉式，延时了数组的创建，节省内存

  • vector
    源码分析：底层创建了长度为10的数组，扩容时扩容为原来长度的2倍

LinkedList

源码分析

LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象

其中，Node定位体现了LinkedList的双向链表的说法

使用LinkedList可以实现队列和栈

add

  • boolean add(E e)：在链表后添加一个元素，如果成功，则返回true，否则返回false；
  • void addFirst(E e)：在链表头部插入一个元素；
  • void addLast(E e)：在链表尾部添加一个元素；
  • void add(int index, E element)：在指定位置插入一个元素。
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("first");
linkedList.add("second");
linkedList.add("third");
System.out.println(linkedList);//[first,second,third]

linkedList.addFirst("addFirst");
System.out.println(linkedList);//[addFirst,first,second,third]

linkedList.addLast("addLast");
System.out.println(linkedList);//[addFirst,first,second,third,addLast]

linkedList.add(2, "addByIndex");
System.out.println(linkedList);//[addFirst,first,addByIndex,second,third,addLast]

remove

  • E remove()；移除链表中第一个元素；
  • boolean remove(Object o)：移除链表中指定的元素；
  • E remove(int index)：移除链表中指定位置的元素；
  • E removeFirst()：移除链表中第一个元素，与remove类似；
  • E removeLast()：移除链表中最后一个元素；
  • boolean removeFirstOccurrence(Object o)：移除链表中第一次出现所在位置的元素；
  • boolean removeLastOccurrence(Object o)：移除链表中最后一次出现所在位置的元素；
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("first");
linkedList.add("second");
linkedList.add("second");
linkedList.add("third");
linkedList.add("four");
linkedList.add("five");
System.out.println(linkedList);//[first,second,second,third,four,five]

linkedList.remove();
System.out.println("remove: " + linkedList);//remove: [second,second,third,four,five]

linkedList.remove("second");
System.out.println("remove(Object): " + linkedList);//remove(Object):[second,third,four,five]

linkedList.remove("six");
System.out.println("remove(Object) not exist: " + linkedList);//remove(Object) not exist: [second,third,four,five]

linkedList.remove(2);
System.out.println("remove(index): " + linkedList);//[second,third,five]

linkedList.removeFirst();
System.out.println("removeFirst: " + linkedList);//[third,five]

linkedList.removeLast();
System.out.println("removeLast:" + linkedList);//[third]

linkedList.clear();//

linkedList.add("first");
linkedList.add("second");
linkedList.add("first");
linkedList.add("third");
linkedList.add("first");
linkedList.add("five");
System.out.println(linkedList);//[first,second,first,third,first,five]

linkedList.removeFirstOccurrence("first");
System.out.println("removeFirstOccurrence: " + linkedList);//[second,first,third,first,five]

linkedList.removeLastOccurrence("first");
System.out.println("removeLastOccurrence: " + linkedList);//[second,first,third,five]

get

  • E get(int index)：按照下标获取元素；
  • E getFirst()：获取第一个元素；
  • E getLast()：获取最后一个元素；

链表前后没有发生变化，只是取出来数

push、pop、poll

  • void push(E e)：与addFirst一样，实际上它就是addFirst；
  • E pop()：与removeFirst一样，实际上它就是removeFirst，返回remove的值；
  • E poll()：查询并移除第一个元素；
LinkedList<String> linkedList = new LinkedList<>();
linkedList.push("first");
linkedList.push("second");
linkedList.push("second");
linkedList.push("third");
linkedList.push("four");
linkedList.push("five");
System.out.println("linkedList: " + linkedList);//[five,four,third,second,second,first]

System.out.println("pop: " + linkedList.pop());//pop: first
System.out.println("after pop: " + linkedList);//after pop:[four,third,second,second,first]

System.out.println("poll: " + linkedList.poll());//poll:four
System.out.println("after poll: " + linkedList);//after poll:[third,second,second,first]

push和pop的操作接近stack的操作
poll和pop的区别

  • poll输出null
  • pop产生异常
LinkedList<String> linkedList = new LinkedList<>();
System.out.println("poll: " + linkedList.poll());//poll:null
System.out.println("pop: " + linkedList.pop());//Exception in thread "main" java.util.NoSuchElementException

peek

  • E peek()：获取第一个元素，但是不移除；
  • E peekFirst()：获取第一个元素，但是不移除；
  • E peekLast()：获取最后一个元素，但是不移除；
LinkedList<String> linkedList = new LinkedList<>();
linkedList.push("first");
linkedList.push("second");
linkedList.push("second");
linkedList.push("third");
linkedList.push("four");
linkedList.push("five");
System.out.println("linkedList: " + linkedList);//linkedList:[five,four,third,second,second,first]
System.out.println("peek: " + linkedList.peek());//peek:five
System.out.println("peekFirst: " + linkedList.peekFirst());//peekFirst:five
System.out.println("peekLast: " + linkedList.peekLast());//peekLast:first

System.out.println("linkedList: " + linkedList);//linkedList:[five,four,third,second,second,first]
  • peek如果没找到对应的元素，统统输出null：

offer

  • boolean offer(E e)：在链表尾部插入一个元素；
  • boolean offerFirst(E e)：与addFirst一样，实际上它就是addFirst；
  • boolean offerLast(E e)：与addLast一样，实际上它就是addLast；
LinkedList<String> linkedList = new LinkedList<>();
linkedList.push("first");
linkedList.push("second");
linkedList.push("second");
linkedList.push("third");
linkedList.push("four");
linkedList.push("five");
System.out.println("linkedList: " + linkedList);//linkedList:[five,four,third,second,second,first]
linkedList.offer("six");
System.out.println("linkedList: " + linkedList);//linkedList:[five,four,third,second,second,first,six]
linkedList.offerFirst("zero");
System.out.println("linkedList: " + linkedList);//linkedList:[zero,five,four,third,second,second,first,six]
linkedList.offerLast("seven");
System.out.println("linkedList: " + linkedList);//linkedList:[zero,five,four,third,second,second,first,six,seven]

其他常用方法中，只有set会改变原链表

System.out.println("linkedList: " + linkedList);
//linkedList:[five, four, third, second, second, first]
System.out.println("linkedList.contains(\"second\"): " + linkedList.contains("second"));//linkedList.contains("second"):true
System.out.println("linkedList.contains(\"six\"): " + linkedList.contains("six"));//false
System.out.println("linkedList.element(): " + linkedList.element());//5个元素
System.out.println("linkedList: " + linkedList);
System.out.println("linkedList.set(3, \"set\"): " + linkedList.set(3, "set"));
System.out.println("linkedList: " + linkedList);//linkedList: [five, four, third, set, second, first]
System.out.println("linkedList.subList(2,4): " + linkedList.subList(2,4));//linkedList.subList(2,4): [third, set]
System.out.println("linkedList: " + linkedList);

Set接口

一、存储无序、不可重复的数据
具体实现类：

  • HashSet：主要实现类，线程不安全，可以存储null值
    • LinkedHashSet：作为hashset的子类；遍历内部数据时，可以按照添加的顺序遍历
    • TreeSet：可以按照添加对象的指定属性，进行排序

set接口中没有额外定义新的方法，使用的都是collection中的方法
要求：向set中添加的数据，其所在的类一定要重写hashcode()和equals()
重写的hashcode()和equals()尽可能保持一致性，相等的对象必须具有相等的散列码

  • 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值
  • 不可重复性：保证添加的元素按照equals方法判断时不能返回true，相同的元素只能添加一次

二、添加元素的过程
首先调用元素所在类的hashCode方法，计算元素a的hash值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为索引位置），判断数组此位置上是否已经有元素存在

  • 如果此位置上没有其他元素存在，则元素a添加成功
  • 如果此位置上有其他元素b存在（或以链表形式存在的多个元素），则比较元素a与元素b的hash值
    • 如果hash值不相同，则元素a添加成功
    • 如果hash值相同，进而调用元素a所在类的equals方法
      • equals返回true，添加失败
      • equals返回false，添加成功
      • 对于添加成功的情况而言：元素a与已经存在的索引位置上以链表的方式存储
      • jdk7:元素a放到数组中，指向原来的元素
      • jdk8：原来的元素在数组中，指向元素a

三、TreeSet
1.向TreeSet中添加的数据，要求是相同类的对象
2.两种排序方式：自然排序（实现compareTo接口）和定制排序
3.自然排序中，比较两个对象是否相同的标准为：compareTo返回0，不再是equals

Map

存储双列数据，存储key-value对的数据
实现类：
HashMap: 作为Map的主要实现类；线程不安全，效率高；可以存储null的key和value

  • LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素，对于频繁的遍历操作，此类执行效率高于HashMap

TreeMap： 有序存储。保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定义排序。底层使用红黑树
Hashtable: 作为Map的古老实现类；线程安全，效率低；有sychronized，不能存储null的key和value

  • Properties：常用来处理配置文件。key和value都是String类型
    Hash

key和value

key：不重复，无序的。用set存储
value：可重复，无序。用collection存储
entry键值对：其中有两个对象k和v，无序，不可重复。用set存储

HashMap的底层实现原理

JDK7：
HashMap map = new HashMap();
实例化之后，底层创建了长度是16的一维数组Entry[] table。
map.put(key1,value1);
首先，调用key1所在类的hashcode()计算key1的哈希值，此哈希值经过某种算法计算之后，得到entry数组中的存放位置。
如果此位置上的数据为空，此时的entry添加成功
如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：

  • 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1和value1添加成功
  • 如果key1的哈希值和已经存在的某一个数据的哈希值相同，继续比较：调用key1所在类的equals(key2)：
    • 如果equals返回false：此时key1-value1添加成功
    • 如果返回true：使用value1替换value2

补充：如果数据不为空时，则新添加的数据和原来的数据以链表的方式存储
扩容方式：扩容为原来的两倍，并把原有数据复制过来

jdk8和jdk7的不同：
1.new HashMap()：底层没有创建一个长度为16的数组
2.底层的数组是Node()，而非Entry()
3.首次调用put()方法时候，底层创建长度为16的数组
4.jdk7底层为数组+链表，jdk8底层为数组+链表+红黑树
当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有数据改为使用红黑树存储。

Map接口中定义的方法

map放数据使用put 函数，是尾插法。

//添加删除和修改
Map map = new Map();
//添加
map.put("AA",123);
map.put(45,123);
map.put("bb",56);
//修改
map.put("AA",87) 
sout(map);
Map map1 = new Map();
map1.put("CC",123);
map1.put("DD",123);

map.putAll(map1);
//remove(key)修改
Object value = map.remove("CC");//移除指定key的键值对，并返回value，如果key值不存在，则返回null

//clear()
map.clear();//只是清空数据，map仍然存在
sout(map.size())//不会报空指针
sout(map)//{}

//元素查询的方法
map.get("CC");//获取指定key对应的value
//是否包含指定的key
boolean isExist = map.containsKey("BB");//是否包含指定的key
boolean isExist2 = map.constainsValue(123);//是否包含指定的value
//int size()返回map中key-value的个数

//boolean isEmpty()判断当前map是否为空

遍历
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection
Set entrySet()：返回所有key-value对构成的Set集合

Map map = new Map();
map.put("AA",123);
map.put(45,123);
map.put("bb",56);
//遍历所有的key集：keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
   System.out.println(iterator.next());
}

//遍历所有的value集：values
Collection values = map.values();
for(Object obj:values){
   sout(obj)
}
//遍历所有的key-value
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while(iterator1.hasNext()){
   
}
只会收藏他人资料的卑微嘎
关注
Java 基础入门 | 第十三章 Java集合
洛阳泰山的博客
02-04 1066
目录 Java集合框架 Collection接口 Iterator接口 List接口以及实现类 Set接口以及实现类 Map接口以及实现类 Collections工具类 Arrays工具类 作业 Java集合框架 集合（collection）有时又称为容器，简单地说，它是一个对象，能将具有相同性质的多个元素汇聚成一个整体 集合被用于存储、获取、操纵和传输聚合的数据 集合框架（Collections Framework）是用来表现和操纵集合的一个统一的体系结构。所有的集合框架都包..
Java学习11 集合与映射
懒人博客
11-10 293
列表（List）、集（Set）、映射（Map）、其他相关API。参考v512工作室培训视频，请勿用于盈利目的。
数据类型-----集合
weixin_30339457的博客
11-20 386
一、集合 1.定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key；集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值。2.特性： 不用元素组成，且元素不重复 无序 元素不可变（数字、字符串、元组） 3.基本格式： s = {1,2,3,4,'age'} print(s) ...
Java集合showInfo,Java集合
weixin_35594924的博客
03-09 445
Java集合Java数组是一个Java对象，数组的长度是固定的，在同一个数组中只能够存放相同类型的数据，数组可以存放基本类型的数据，也可以存放引用类型的数据。在创建数组对象时，必须指定数组对象的长度，数组一旦创建，它的长度就不能再变(1)创建数组对象(即new一个数组时)要指定数组的长度，数组的长度一旦指定，就不能够再发生变化；(2)同一个数组中的数据的类型必须相同，可以是基本类型，也可以是引用类...
第十四章 Java集合
你好, 我在学java的博客
11-13 5596
创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法去除重复元素，如果方法返回0，就认为不应该添加；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法去除重复元素；原因：创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法比较；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法比较；第二次添加时，遍历所有的key。
第十一章 集合
winter25的博客
03-23 615
Collection接口和Map接口是并列关系， 存储数据的特点不同。学习要求：学完后要知道什么类型的数据适合什么结构去存储 一、集合框架概述 1.理解集合 * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 * 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中） * //【持久化的存储：硬盘、服务器、数据库。讲到IO流时再讲】 * * 2.1 数组在存储多个数据方面的特点： * > 一旦初始化以后，其长
java集合（详解）
abc98526的博客
04-24 1万+
文章目录 什么是集合? Collection的基本使用 接口实现类 Collections工具类 Map接口及其实现类 Map是不是集合? 什么是集合? 集合是指具有某种特定性质的具体的或抽象的对象汇总而成的集体，有时集合也称之为容器，java中在util包...
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合
热门推荐
云深不知处
11-09 27万+
Java8 Stream横空出世，让我们从繁琐冗长的迭代中解脱出来，集合数据操作变得优雅简洁。 这些操作：集合的filter（筛选）、归约（reduce）、映射（map）、收集（collect）、统计（max、min、avg）等等，一行代码即可搞定！ 让我们一起敲打案例代码，搞定Java8 stream吧！
Java 44个集合面试题及答案
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 2448
但从更大的范围和使用来看，Java 1.2 提出了集合框架，将所有集合接口、实现和算法分组。Java 集合通过使用泛型和并发集合类实现线程安全操作已经取得了长足的进步。它还包括 Java 并发包中的阻塞接口及其实现。通过使用核心集合类而不是实现我们自己的集合类来减少开发工作量。通过使用经过充分测试的集合框架类，代码质量得到提高。通过使用 JDK 附带的集合类减少代码维护工作量。可重用性和互操作性。
Java OOP 7 JAVA 集合框架
云哥的博客
04-05 2173
Java 集合框架 提供了一套性能优良、使用方便的接口和类 位于java.util包中 集合中的元素全部是对象，即Object类的实例 不同的集合类有不同的功能和特点，适合不同的场合
java第11章java-chapter11.rar
06-26
在本压缩包"java第11章java-chapter11.rar"中，我们可能涵盖了Java的高级特性和关键概念，这些通常包括异常处理、多线程、集合框架、输入/输出(I/O)系统、网络编程以及Java的高级设计模式。 1. **异常处理**：Java...
第11章 集合1
08-08
2. **集合框架集**（Collection Framework）是Java提供的一种更灵活的数据结构集合，它包括一系列接口和类，如`Collection`、`List`、`Set`和`Map`等，它们在`java.util`包中定义，满足不同逻辑关系和操作需求。...
Java集合框架
12-22
Java集合框架是Java编程语言中一个至关重要的组件，它为开发者提供了存储和管理对象的统一方式。集合可以被看作是一个容器，允许我们存放多个对象，并支持常见的操作，如添加、删除和修改元素。 Collection接口是...
java语言程序与数据结构梁勇第十版第七章复习题答案
06-06
在“Java语言程序与数据结构梁勇第十版第七章复习题答案”中，我们主要探讨的是Java编程语言的基础知识，特别是与数据结构相关的概念。Java作为一种面向对象的编程语言，对于初学者来说，理解其基本语法、类和对象、...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 325
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 392
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 704
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 690
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
Java第11章：Iterator遍历与集合框架详解
在Java编程中，第11章主要探讨了集合（Collection）这一核心概念及其在程序设计中的应用。集合是Java中一个重要的数据结构，它提供了管理和操作一组对象的抽象方式，解决了数组在扩展性、插入和删除操作上的局限性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值