java集合精解

2024-02-07 11:32
文章标签 java 集合 精解

本文主要是介绍java集合精解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

面试常见问题
 ArrayList和LinkedList的联系和区别

                 1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
                 2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 
                 3. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据
        Vector和ArrayList的联系和区别 

                 1、Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了                                Vector在效率上无法与ArrayList相比；

                 2、两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同的，很多网友说Vector增加原来空间的一倍，ArrayList增加原来空间的50%，其实也差不多是这个意思，不过还有一点点问题可以从源码中看出，一会儿从源码中分析。

                  3、Vector可以设置增长因子，而ArrayList不可以。


在说集合前我们不得不说一下数组
数组的作用：存放一组相同的数据类型(基本或对象)的数据，从而实现对数据的管理
优势：可以快速的通过下标对数组元素进行访问，效率高
劣势：容量实现定义好了，不能随着需求变化而扩容
因此出现了更好的集合框架
一、数组和集合的比较
数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。如下：
·1：数组能存放基本数据类型和对象，而集合类存放的都是对象的引用，而非对象本身！
·2：数组容易固定无法动态改变，集合类容量动态改变。 
·3：数组无法判断其中实际存有多少元素，length只告诉了数组的容量，而集合的size()可以确切知道元素的个数 
·4：集合有多种实现方式和不同适用场合，不像数组仅采用顺序表方式 
·5：集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性即可实现各种复杂操作，大大提高了软件的开发效率
二、java集合主要由两个接口派生：Collection和Map，是集合框架的根接口。
collection的子接口：Set:接口 ---实现类： HashSet、LinkedHashSet
   set的子接口SortedSet接口---实现类：TreeSet
  List:接口---实现类： LinkedList,Vector,ArrayList 


List:有序列表，允许存放重复的元素； 
实现类： 
ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级  (线程安全、使用少)


Set:无序集合，不允许存放重复的元素；允许使用null元素
HashSet 的后台有一个HashMap;初始化后台容量；只不过生成一个HashSet的话，系统只提供key的访问； 如果有两个Key重复，那么会覆盖之前的； 
实现类 
HashSet：equals返回true，hashCode返回相同的整数；哈希表；存储的数据是无序的。
LinkedHashSet：此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。存储的数据是有序的。
哈希表详解http://www.bianceng.cn/Programming/sjjg/200705/1126.htm 
http://blog.csdn.net/feixiaoxing/article/details/6885657
http://blog.csdn.net/jdh99/article/details/8490704


子接口SortedSet,对Set排序实现类 :TreeSet：使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序；二叉树实现的； 
二叉树详解：http://blog.csdn.net/luckyxiaoqiang/article/details/7518888/
http://blog.csdn.net/pony_maggie/article/details/38390513


Map的实现类：HashMap、TreeMap、LinkedHashMap、Hashtable等
HashMap：键值对，key不能重复，但是value可以重复；key的实现就是HashSet；value对应着放；允许null的键或值；
Hashtable：线程安全的，不允许null的键或值；
Properties:：key和value都是String类型，用来读配置文件；
TreeMap：对key排好序的Map; key 就是TreeSet, value对应每个key; key要实现Comparable接口或TreeMap有自己的构造器； 
LinkedHashMap： 此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。存储的数
据是有序的。


接口

简述

实现

操作特性

成员要求

Set

成员不能重复

HashSet

外部无序地遍历成员

成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

TreeSet

外部有序地遍历成员；附加实现了SortedSet, 支持子集等要求顺序的操作

成员要求实现caparable接口，或者使用 Comparator构造TreeSet。成员一般为同一类型。

LinkedHashSet

外部按成员的插入顺序遍历成员

成员与HashSet成员类似

List

提供基于索引的对成员的随机访问

ArrayList

提供快速的基于索引的成员访问，对尾部成员的增加和删除支持较好

成员可为任意Object子类的对象

LinkedList

对列表中任何位置的成员的增加和删除支持较好，但对基于索引的成员访问支持性能较差

成员可为任意Object子类的对象

Map

保存键值对成员，基于键找值操作，compareTo或compare方法对键排序

HashMap

能满足用户对Map的通用需求

键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

TreeMap

支持对键有序地遍历，使用时建议先用HashMap增加和删除成员，最后从HashMap生成TreeMap；附加实现了SortedMap接口，支持子Map等要求顺序的操作

键成员要求实现caparable接口，或者使用Comparator构造TreeMap。键成员一般为同一类型。

LinkedHashMap

保留键的插入顺序，用equals 方法检查键和值的相等性

成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

IdentityHashMap

使用== 来检查键和值的相等性。

成员使用的是严格相等

WeakHashMap

其行为依赖于垃圾回收线程，没有绝对理由则少用

 



三、Collection常见方法
add(E e); addAll(Collection c);clear();contains(Obj o);返回是否包含指定的元素(true false) 


containsAll(Collection c)是否包含c中所有元素 isEmpty(); iterator();remove();size();toArray();返回


collection中所有元素的数组
四、集合的遍历
     1、增强for循环 for(Obj o:c){syso(o)}
     2、使用iterator ， Iterator it=c.iterator;
          while(it.hasNext()){Object o = it.next()}
     3、普通循环：for(Iterator it=c.iterator();it.hasNext();){it.next() }

五、代码实例

[java] view plain copy
print ?
  1.  1、 ArrayList  
  2. import java.util.ArrayList;    
  3.     
  4. /**  
  5.  *   
  6.  * 关于ArrayList的基本操作   
  7.  * 其它操作感兴趣的读者可以自己结合源码实现一下  
  8.  *  * @author erqing  
  9.  *   
  10.  */    
  11. public class ListTest {    
  12.     
  13.     public static void main(String[] args) {    
  14.     
  15.         /* 新建一个ArrayList */    
  16.         ArrayList<String> list = new ArrayList<String>();    
  17.         System.out.println("初始化大小:" + list.size());    
  18.     
  19.         /* 添加元素 */    
  20.         list.add("zzz");    
  21.         list.add("egg");    
  22.         list.add("hell");    
  23.         list.add("child");    
  24.         System.out.println("当前容量:" + list.size());    
  25.     
  26.         /* 将ArrayList的大小和实际所含元素的大小设置一致 */    
  27.         list.trimToSize();    
  28.     
  29.         /* 遍历 */    
  30.         for (String string : list) {    
  31.             System.out.println(string);    
  32.         }    
  33.     
  34.         /* 在指定位置插入元素 */    
  35.         list.add(2, "zhu");    
  36.     
  37.         for (String string : list) {    
  38.             System.out.println(string);    
  39.         }    
  40.     
  41.         System.out.println("--------------");    
  42.     
  43.         /* 清空list */    
  44.         list.clear();    
  45.     
  46.         /* 遍历 */    
  47.         for (String string : list) {    
  48.             System.out.println(string);    
  49.         }    
  50.         System.out.println("--------------");    
  51.     }    
  52. }    
  53.   2、LinkedList  
  54. import java.util.LinkedList;    
  55.     
  56. public class LinkedListTest {    
  57.         
  58.     public static void main(String[] args) {    
  59.     
  60.         /* 新建一个list */    
  61.         LinkedList<Integer> list = new LinkedList<Integer>();    
  62.         System.out.println(list.size());    
  63.     
  64.         /* 向list中添加元素 */    
  65.         list.add(222);    
  66.         list.add(111);    
  67.         list.add(0);    
  68.         list.add(3333);    
  69.         list.add(8888);    
  70.             
  71.         System.out.println(list.size());    
  72.     
  73.         /* 遍历list */    
  74.         for (Integer integer : list) {    
  75.             System.out.println(integer);    
  76.         }    
  77.     
  78.         /* 获取第一个元素 ,即header的next域*/    
  79.         System.out.println("第一个元素是:" + list.getFirst());    
  80.             
  81.         /*获取最后一个元素,即header的previous域*/    
  82.         System.out.println("最后一个元素是:"+list.getLast());    
  83.     }    
  84. }    
  85.   
  86. 3、hashset  
  87.     public static void main(String[] args) {  
  88.         Set set = new HashSet();  
  89.         set.add("a");  
  90.         set.add("b");  
  91.         System.out.println(set);  
  92.         Student stu= new Student(18, "小名", 60);  
  93.         set.add(stu);//调用第一个对象的hashcode方法  调  equals  
  94.         set.add(new Student(19, "小明", 60));  
  95.         set.add(new Student(19, "小明", 60));  
  96.         set.add(new Student(20, "小明", 61));  
  97.         System.out.println(set);  
  98.     }  
  99. 4、treeset  
  100. import java.util.ArrayList;  
  101. import java.util.HashSet;  
  102. import java.util.TreeSet;  
  103.   
  104. /** 
  105.  * 使用treeset存放一组学生成绩 
  106.  *  1、可以自动排序(系统类  自然排序) 
  107.  *  2、不可重复(去重) 
  108.  *  3、只能存放一种数据类型 
  109.  *  ---存放到 treeset中的元素必须要具有比较能力 
  110.  *      调用compareTo() 如果得到的结果为0 ， 两个元素相等 
  111.  *      1 ---》排到后面 
  112.  *      -1 --->排到前面 
  113.  *       
  114.  *  hashset:-->hashtable(哈希表) 
  115.  *  treeset:-->二叉树，红黑树算法 
  116.  *  每存入一个元素就会调用一次compareTo方法 
  117.  * @author Administrator 
  118.  * 
  119.  */  
  120. import java.util.Comparator;  
  121. /** 
  122.  * 外部比较器，当系统类提供的比较规则满足不了需求时使用 
  123.  *   1、自己创建一个比较器  实现  Comprator接口 ，添加一个泛型（需要比较的数据类型） 
  124.  *   2、重写comprae方法,用来比较，参数是两个需要比较的对象 
  125.  * @author Administrator 
  126.  * 
  127.  */  
  128. public class MyStrCompartor implements Comparator<String>{  
  129.   
  130.     @Override  
  131.     public int compare(String o1, String o2) {  
  132.         //按照字符串长度排序  
  133.           
  134.         return o1.length() - o2.length();  
  135.     }  
  136.   
  137. }  
  138.   
  139.   
  140. public class TestTreeSet02 {  
  141.   
  142.     public static void main(String[] args) {  
  143.         //使用外部比较器，  
  144.         //1 拿到比较器的对象  
  145.         MyStrCompartor mcom = new MyStrCompartor();  
  146.         //2在创建集合时，调用有参的构造方法，把比较器传进去  
  147.         //3、在treeset中添加元素时，会优先调用自定义比较器的方法  
  148.         //treeset专用  
  149.         TreeSet ts = new TreeSet(mcom);  
  150. //      ts.add(20);//自动装箱  
  151. //      ts.add(1);  
  152. //      ts.add(100);  
  153. //      ts.add(7);  
  154. //      ts.add(8);  
  155. //      ts.add(100);  
  156.         System.out.println(ts);  
  157.         //需求：不希望按照系统的排序来排列  
  158.         //自己创建一个比较规则  
  159.         ts.add("xiaomi32313");  
  160.         ts.add("zhangliguo5");  
  161.         ts.add("asima1");  
  162.         ts.add("baibaibai4");  
  163.         ts.add("sansan2");  
  164. //      ts.add(new Student("yushen", 19, 19));  
  165. //      ts.add(new Student("xiaoming", 19, 19));  
  166. //      ts.add(new Student("axiaoming1", 19, 18));  
  167.         System.out.println(ts);  
  168.     }  
  169.   
  170. }  
  171.   
  172. 5、hashmap  
  173. import java.util.HashMap;    
  174. import java.util.Map;    
  175. import java.util.Set;    
  176.     
  177. /**  
  178.  * HashMap的使用  
  179.  * @author erqing  
  180.  *   
  181.  */    
  182. public class MapTest {    
  183.     
  184.     public static void main(String[] args) {    
  185.     
  186.         /* 初始化map */    
  187.         Map<String, Integer> map = new HashMap<String, Integer>();    
  188.         System.out.println("HashMap的初始值:" + map.size());    
  189.         System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));    
  190.     
  191.         /* 想map中添加元素 */    
  192.         map.put("erqing", 1);    
  193.         map.put("niuniu", 2);    
  194.         map.put("egg", 3);    
  195.         System.out.println(map.size());    
  196.         ;    
  197.         System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));    
  198.     
  199.         /* 遍历HashMap中的元素 */    
  200.         Set<String> set = map.keySet();    
  201.         for (String s : set) {    
  202.             System.out.println(s + " " + map.get(s) + " " + "hashcode:"    
  203.                     + s.hashCode());    
  204.         }    
  205.     
  206.         /*检测是否含有某个Key*/    
  207.         System.out.println(map.containsKey("egg"));    
  208.             
  209.         /*检测是否含有某个Value*/    
  210.         System.out.println(map.containsValue(2));    
  211.             
  212.         /*打印hashCode*/    
  213.         System.out.println(map.hashCode());    
  214.     }    
  215. }    
  216. /* 
  217. 输出： 
  218. HashMap的初始值:0 
  219. HashMap是否为空:是 
  220. 3 
  221. HashMap是否为空:否 
  222. niuniu 2 hashcode:-1045196352 
  223. egg 3 hashcode:100357 
  224. erqing 1 hashcode:-1294670850 
  225. true 
  226. true 
  227. 1955200455 
  228. */  
  229.   
  230. 6、treemap  
  231. public static void main(String[] args) {    
  232.             
  233.         SortedMap<String, Integer> map = new TreeMap<String, Integer>();    
  234.         map.put("zgg", 1);    
  235.         map.put("erqing", 3);    
  236.         map.put("niu", 0);    
  237.         map.put("abc", 2);    
  238.         map.put("aaa", 5);    
  239. //  map.put(1004, new Student("04",18 ,1004));  
  240. //  map.put(1005, new Student("05",18 ,1005));    也能存new  
  241.         Set<String> keySet = map.keySet();    
  242.         for (String string : keySet) {    
  243.             System.out.print(map.get(string)+" ");    
  244.         }    
  245.     }    
  246. //输出：5 2 3 0 1  
 1、 ArrayList
import java.util.ArrayList;  /** *  * 关于ArrayList的基本操作  * 其它操作感兴趣的读者可以自己结合源码实现一下 *  * @author erqing *  */  
public class ListTest {  public static void main(String[] args) {  /* 新建一个ArrayList */  ArrayList<String> list = new ArrayList<String>();  System.out.println("初始化大小:" + list.size());  /* 添加元素 */  list.add("zzz");  list.add("egg");  list.add("hell");  list.add("child");  System.out.println("当前容量:" + list.size());  /* 将ArrayList的大小和实际所含元素的大小设置一致 */  list.trimToSize();  /* 遍历 */  for (String string : list) {  System.out.println(string);  }  /* 在指定位置插入元素 */  list.add(2, "zhu");  for (String string : list) {  System.out.println(string);  }  System.out.println("--------------");  /* 清空list */  list.clear();  /* 遍历 */  for (String string : list) {  System.out.println(string);  }  System.out.println("--------------");  }  
}  2、LinkedList
import java.util.LinkedList;  public class LinkedListTest {  public static void main(String[] args) {  /* 新建一个list */  LinkedList<Integer> list = new LinkedList<Integer>();  System.out.println(list.size());  /* 向list中添加元素 */  list.add(222);  list.add(111);  list.add(0);  list.add(3333);  list.add(8888);  System.out.println(list.size());  /* 遍历list */  for (Integer integer : list) {  System.out.println(integer);  }  /* 获取第一个元素 ,即header的next域*/  System.out.println("第一个元素是:" + list.getFirst());  /*获取最后一个元素,即header的previous域*/  System.out.println("最后一个元素是:"+list.getLast());  }  
}  3、hashsetpublic static void main(String[] args) {Set set = new HashSet();set.add("a");set.add("b");System.out.println(set);Student stu= new Student(18, "小名", 60);set.add(stu);//调用第一个对象的hashcode方法  调  equalsset.add(new Student(19, "小明", 60));set.add(new Student(19, "小明", 60));set.add(new Student(20, "小明", 61));System.out.println(set);}
4、treeset
import java.util.ArrayList;
import java.util.HashSet;
import java.util.TreeSet;/*** 使用treeset存放一组学生成绩* 	1、可以自动排序(系统类  自然排序)*  2、不可重复(去重)*  3、只能存放一种数据类型*  ---存放到 treeset中的元素必须要具有比较能力*  	调用compareTo() 如果得到的结果为0 ， 两个元素相等*      1 ---》排到后面*      -1 --->排到前面*      *  hashset:-->hashtable(哈希表)*  treeset:-->二叉树，红黑树算法*  每存入一个元素就会调用一次compareTo方法* @author Administrator**/
import java.util.Comparator;
/*** 外部比较器，当系统类提供的比较规则满足不了需求时使用*   1、自己创建一个比较器  实现  Comprator接口 ，添加一个泛型（需要比较的数据类型）*   2、重写comprae方法,用来比较，参数是两个需要比较的对象* @author Administrator**/
public class MyStrCompartor implements Comparator<String>{@Overridepublic int compare(String o1, String o2) {//按照字符串长度排序return o1.length() - o2.length();}}public class TestTreeSet02 {public static void main(String[] args) {//使用外部比较器，//1 拿到比较器的对象MyStrCompartor mcom = new MyStrCompartor();//2在创建集合时，调用有参的构造方法，把比较器传进去//3、在treeset中添加元素时，会优先调用自定义比较器的方法//treeset专用TreeSet ts = new TreeSet(mcom);
//		ts.add(20);//自动装箱
//		ts.add(1);
//		ts.add(100);
//		ts.add(7);
//		ts.add(8);
//		ts.add(100);System.out.println(ts);//需求：不希望按照系统的排序来排列//自己创建一个比较规则ts.add("xiaomi32313");ts.add("zhangliguo5");ts.add("asima1");ts.add("baibaibai4");ts.add("sansan2");
//		ts.add(new Student("yushen", 19, 19));
//		ts.add(new Student("xiaoming", 19, 19));
//		ts.add(new Student("axiaoming1", 19, 18));System.out.println(ts);}}5、hashmap
import java.util.HashMap;  
import java.util.Map;  
import java.util.Set;  /** * HashMap的使用 * @author erqing *  */  
public class MapTest {  public static void main(String[] args) {  /* 初始化map */  Map<String, Integer> map = new HashMap<String, Integer>();  System.out.println("HashMap的初始值:" + map.size());  System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));  /* 想map中添加元素 */  map.put("erqing", 1);  map.put("niuniu", 2);  map.put("egg", 3);  System.out.println(map.size());  ;  System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));  /* 遍历HashMap中的元素 */  Set<String> set = map.keySet();  for (String s : set) {  System.out.println(s + " " + map.get(s) + " " + "hashcode:"  + s.hashCode());  }  /*检测是否含有某个Key*/  System.out.println(map.containsKey("egg"));  /*检测是否含有某个Value*/  System.out.println(map.containsValue(2));  /*打印hashCode*/  System.out.println(map.hashCode());  }  
}  
/*
输出：
HashMap的初始值:0
HashMap是否为空:是
3
HashMap是否为空:否
niuniu 2 hashcode:-1045196352
egg 3 hashcode:100357
erqing 1 hashcode:-1294670850
true
true
1955200455
*/6、treemap
public static void main(String[] args) {  SortedMap<String, Integer> map = new TreeMap<String, Integer>();  map.put("zgg", 1);  map.put("erqing", 3);  map.put("niu", 0);  map.put("abc", 2);  map.put("aaa", 5);  
//	map.put(1004, new Student("04",18 ,1004));
//	map.put(1005, new Student("05",18 ,1005));    也能存newSet<String> keySet = map.keySet();  for (String string : keySet) {  System.out.print(map.get(string)+" ");  }  }  
//输出：5 2 3 0 1



更多内容：http://blog.csdn.net/zhangerqing/article/details/8122075


持续更新，欢迎大家一起交流
邮箱：960576866@qq.com
未完，待续

这篇关于java集合精解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/687593。

相关文章

Java实现Excel与HTML互转

Java实现Excel与HTML互转

《Java实现Excel与HTML互转》Excel是一种电子表格格式,而HTM则是一种用于创建网页的标记语言,虽然两者在用途上存在差异,但有时我们需要将数据从一种格式转换为另一种格式,下面我们就来看看... Excel是一种电子表格格式，广泛用于数据处理和分析，而HTM则是一种用于创建网页的标记语言。虽然两
阅读更多...
java图像识别工具类(ImageRecognitionUtils)使用实例详解

java图像识别工具类(ImageRecognitionUtils)使用实例详解

《java图像识别工具类(ImageRecognitionUtils)使用实例详解》：本文主要介绍如何在Java中使用OpenCV进行图像识别,包括图像加载、预处理、分类、人脸检测和特征提取等步骤... 目录前言1. 图像识别的背景与作用2. 设计目标3. 项目依赖4. 设计与实现 ImageRecogni
阅读更多...
Java中Springboot集成Kafka实现消息发送和接收功能

Java中Springboot集成Kafka实现消息发送和接收功能

《Java中Springboot集成Kafka实现消息发送和接收功能》Kafka是一个高吞吐量的分布式发布-订阅消息系统,主要用于处理大规模数据流,它由生产者、消费者、主题、分区和代理等组件构成,Ka... 目录一、Kafka 简介二、Kafka 功能三、POM依赖四、配置文件五、生产者六、消费者一、Kaf
阅读更多...
Java访问修饰符public、private、protected及默认访问权限详解

Java访问修饰符public、private、protected及默认访问权限详解

《Java访问修饰符public、private、protected及默认访问权限详解》：本文主要介绍Java访问修饰符public、private、protected及默认访问权限的相关资料,每... 目录前言1. public 访问修饰符特点：示例：适用场景：2. private 访问修饰符特点：示例：
阅读更多...
详解Java如何向http/https接口发出请求

详解Java如何向http/https接口发出请求

《详解Java如何向http/https接口发出请求》这篇文章主要为大家详细介绍了Java如何实现向http/https接口发出请求,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 用Java发送web请求所用到的包都在java.net下，在具体使用时可以用如下代码，你可以把它封装成一
阅读更多...
SpringBoot使用Apache Tika检测敏感信息

SpringBoot使用Apache Tika检测敏感信息

《SpringBoot使用ApacheTika检测敏感信息》ApacheTika是一个功能强大的内容分析工具,它能够从多种文件格式中提取文本、元数据以及其他结构化信息,下面我们来看看如何使用Ap... 目录Tika 主要特性1. 多格式支持2. 自动文件类型检测3. 文本和元数据提取4. 支持 OCR（光学
阅读更多...
Java内存泄漏问题的排查、优化与最佳实践

Java内存泄漏问题的排查、优化与最佳实践

《Java内存泄漏问题的排查、优化与最佳实践》在Java开发中,内存泄漏是一个常见且令人头疼的问题,内存泄漏指的是程序在运行过程中,已经不再使用的对象没有被及时释放,从而导致内存占用不断增加,最终... 目录引言1. 什么是内存泄漏？常见的内存泄漏情况2. 如何排查 Java 中的内存泄漏？2.1 使用 J
阅读更多...
JAVA系统中Spring Boot应用程序的配置文件application.yml使用详解

JAVA系统中Spring Boot应用程序的配置文件application.yml使用详解

《JAVA系统中SpringBoot应用程序的配置文件application.yml使用详解》：本文主要介绍JAVA系统中SpringBoot应用程序的配置文件application.yml的... 目录文件路径文件内容解释1. Server 配置2. Spring 配置3. Logging 配置4. Ma
阅读更多...
Java 字符数组转字符串的常用方法

Java 字符数组转字符串的常用方法

《Java字符数组转字符串的常用方法》文章总结了在Java中将字符数组转换为字符串的几种常用方法,包括使用String构造函数、String.valueOf()方法、StringBuilder以及A... 目录1. 使用String构造函数1.1 基本转换方法1.2 注意事项2. 使用String.valu
阅读更多...
java脚本使用不同版本jdk的说明介绍

java脚本使用不同版本jdk的说明介绍

《java脚本使用不同版本jdk的说明介绍》本文介绍了在Java中执行JavaScript脚本的几种方式,包括使用ScriptEngine、Nashorn和GraalVM,ScriptEngine适用... 目录Java脚本使用不同版本jdk的说明1.使用ScriptEngine执行javascript2.
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2