Java 集合操作,Java集合知识点
List集合：
数组列表：
是存储有序和可重复对象的基础数组结构。
包装设置测试；导入Java . util . ArrayList；导入Java . util . collections；导入Java . util . list；class ArrayList Test { public static void main(string[]args){//创建ArrayList的对象list integer list=new ArrayList()；//使用add方法添加list . add(1)；list . add(2)；//是可重复的list . add(2)；list . add(3)；list . add(4)；//使用集合工具类Collections Collections . sort(list)；//sort collections . reverse(list)；//Invert system . out . println(list . tostring())；}}输出：
[1，2，2，3，4][4，3，2，2，1]//在ArrayList中复制数据是可以的。
链接列表：
双向链表存储，存储有序的、可重复的对象。LinkedList的实现机制与ArrayList不同。ArrayList的底层是通过数组实现的。每次插入一个值，先扩展几组的长度，数组的值用下标获取。所以查询元素的效率很高，但是插入和删除元素的位移效率很低。因此，通常建议使用LinkedList而不是ArrayList。LinkedList存储在双向链表中，添加和删除元素时不需要位移，所以插入和删除效率高。
链表的存储结构：
总结：有很多查询的时候用ArrayList，有很多删除和插入的时候用LinkedList。
list integer list=new linked list()；//创建LinkedList对象。其他操作与ArrayList一致。
向量：
Vector和ArrayList集合之间没有太大的区别。底层是用数组实现的，功能是一样的。它用于存储大量有序且可重复的对象，一般用于查询大量数据。唯一的区别是Vector是线程安全的，ArrayList是非线程安全的。
list integer list=new Vector()；//创建Vector对象。其他操作与ArrayList一致。
Set集合：
哈希集：
哈希算法用于记录内存中无序存储的对象。
HashSet源代码：
public HashSet(){ map=new HashMap()；}说明HashSet的底层是一个无序的集合，依靠HashMap以键值对的形式存储。值是通过键找到的，但是键是通过哈希算法存储的无序集合。
树集：
TreetSet是SortSet接口的实现类，TreeSet可以保证元素在保存前排序。它使用红黑树算法数据结构来存储集合元素。TreeSet支持两种排序：自然排序和自定义排序，默认是自然排序。
自然排序：
包装设置测试；导入Java . util . set；导入Java . util . treeset；public TreeSet test { public static void main(string[]args){//TreeSet是先对值进行排序，然后用红黑树算法保存set integer tre=new TreeSet()；tre . add(5)；tre . add(3)；tre . add(8)；tre . add(1)；tre . add(4)；for(整数val : tre){ system . out . println(val)；}}}输出：
13458
kquote>定制排序：
Student类：
package TreeSet;public class Student implements Comparable<Student> { private String name; private int age; private char sex; public Student(String name, int age, char sex) { this.name = name; this.age = age; this.sex = sex; } @Override public String toString(){ return "学生的信息是{"+name+age+sex+"}"; } @Override public int compareTo(Student obj) { //这里使用年龄来比较排序 int num = this.age-obj.age; return num; }}测试类：
package TreeSet;import java.util.Set;import java.util.TreeSet;public class test { public static void main(String[] args) {//这里生成对象的年龄不按照大小来生成 Student stu1 = new Student("张三",40,男); Student stu2 = new Student("李四",32,男); Student stu3 = new Student("王五",25,男); Set<Student> treeSet = new TreeSet<>(); treeSet.add(stu1); treeSet.add(stu2); treeSet.add(stu3); for (Student stu:treeSet ) { System.out.println(stu.toString()); } }}输出结果：
结果就是按照年龄的大小来进行排序：（这个就是TreeSet的定制排序）
学生的信息是{王五25男}学生的信息是{李四32男}学生的信息是{张三40男}
LinkedHashSet：
内部是一个双向链表式结构，所以它插入的值式有序的。因为它插入的时候是使用链表式维护插入的顺 序，所以获取元素的时候应该和插入的顺序一致。但是LinedHashSet性能上低于HashSet，因为除了维护值 以外还需要维护他们的顺序：
package SetTest;import java.util.HashSet;import java.util.LinkedHashSet;import java.util.Set;public class LinkedHashSetTest { public static void main(String[] args) { //LinkedHashSet 按照插入的顺序读取值 Set<Integer> set = new LinkedHashSet<>(); set.add(40); set.add(20); set.add(10); set.add(30); for (Integer val:set){ System.out.println(val); } }}输出：（会按照输入的顺序去读值）
40201030
Map集合：
HashMap：
import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;public class MapTest { public static void main(String[] args) { Map<String,String> map = new HashMap<>(); map.put("red","红色"); map.put("yellow","黄色"); map.put("green","绿色"); System.out.println(map); System.out.println(map.get("yellow"));//通过get键去获取值}}输出：
{red=红色, green=绿色, yellow=黄色}黄色 // System.out.println(map.get("yellow"));
HashMap的两种遍历方法：
通过for遍历所有的键，根据键来获取到值（接上部分代码即可）
for (String stu:map.values() ) System.out.println(stu.toString());{ }输出：
红色绿色黄色
用迭代器的方式：（接上部分代码即可）
Set<String> keys = map.keySet(); Iterator<String> it = keys.iterator(); while(it.hasNext()){ String key = it.next(); String stu = map.get(key); System.out.println(stu.toString());}输出：
红色绿色黄色
注意：如果是存储大量的数据，我们一般是不会用Map去存储。Map一般用于存储小量并且可以无序的 键值对存储的数据。比如登录页面的用户名、密码等等。
LinkedHashMap：
LinkedHashMap是以链表式存储的HashMap，并且是以Hash算法来获取hashcode的值来获取内存中的数 据，存储的顺序和读取的顺序一致：
import java.util.LinkedHashMap;import java.util.Map;public class LinkHashMap { public static void main(String[] args) {//在HashMap里面，添加使用put方法！！ Map<String,String> map = new LinkedHashMap<>(); map.put("yellow","黄色"); map.put("green","绿色"); map.put("red","红色"); System.out.println(map); }}输出：
{yellow=黄色, green=绿色, red=红色}
HashTable：
Map<String,String> map = new Hashtable<>();
HashMap和HashTable的作用一样，都是无序的键值对形式存储，HashTable考虑线程安全，HashMap不考 虑线程安全，其他操作一致。
ConcurrentHashMap: 也是和HashMap线程一样，但是它考虑线程安全。HashTable是采用给当前线程加锁实现线程安全， ConcurrentHashMap是采用分段锁机制来实现线程安全：
Map<String,String> map = new ConcurrentHashMap<>();
EnumMap：
专门用来存储枚举的Map集合：
package SetTest;import java.util.Map;public class EnumMap { //枚举 public enum color{ RED,GREEN,YELLOW } public static void main(String[] args) { //枚举map Map<color,String> map = new java.util.EnumMap<color, String>(color.class); map.put(color.RED,"红灯"); map.put(color.GREEN,"绿灯"); map.put(color.YELLOW,"黄灯"); System.out.println(color.RED); String info = map.get(color.RED); System.out.println("信号信息是："+info); }}集合和数组之间的转换：
import com.sun.corba.se.spi.ior.ObjectKey;import java.util.Arrays;import java.util.List;/** * 集合和数组之间的转换 */public class SetToArr { public static void main(String[] args) { String name [] = new String[]{"张三","李四","王五","赵六"}; //将各种数据转换成list集合 List<String> list1 = Arrays.asList(name); List<String> list2 = Arrays.asList("aa","bb","cc"); List<Integer> list3 = Arrays.asList(100,200,300); System.out.println("list集合："+list2); //list转数组 Object [] newArr = list2.toArray(); String newStr = list2.toString(); System.out.println("数组："+newStr); }}输出：
list集合：[aa, bb, cc]数组：[aa, bb, cc]
这些就是常用的集合代码举例，大家可以结合上一章的理论知识来看，在这里写的都是一些很简洁的例子，大家多看看就可以理解。
到此这篇关于Java十分钟精通集合的使用与原理下篇的文章就介绍到这了,更多相关Java 集合内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。