Java 集合
热爱飞行的小应学长 人气:0List集合：
ArrayList：
底层是数组结构，储存有序并且可以重复的对象
package SetTest;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayListTest {
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); //排序
Collections.reverse(list); //反转
System.out.println(list.toString());
}
}输出：
[1, 2, 2, 3, 4]
[4, 3, 2, 2, 1]
//在ArrayList中重复数据是没问题的
LinkedList：
双向链表式存储，存储有序可重复的对象。LinkedList的实现机制与ArrayList的不同，ArrayList底层是数组实现的，每次插入值的时候先扩容数 组的长度，通过下标获取到该数组的值因此查询元素的效率很高，但是插入和删除需要位移效率很低，所以经 常对元素插入或者删除操作建议不要使用ArrayList，而要采用LinkedList。LinkedList采用双向链表 式存储在增加和删除元素的时候不需要位移，插入和删除效率高。
LinkedList的储存结构：
总结：查询多的时候用ArrayList，删除和插入多就用LinkedList
List<Integer> list = new LinkedList<>();//创建LinkedList的对象
其他操作与ArrayList一致
Vector：
Vector和ArrayList集合没有什么太大的区别，底层都是数组实现的，作用也是一致，用来存储大量的有序 的可重复的对象，一般用于大量数据的查询。唯一的区别在于Vector是线程安全的，ArrayList是非线程安全的。
List<Integer> list = new Vector<>();//创建Vector的对象
其他操作与ArrayList一致
Set集合：
HashSet：
是以Hash算法来记录再内存中无序存储的对象
HashSet源码：
public HashSet() {
map = new HashMap<>();
}说明HashSet底层是依赖于HashMap以键值对的形式来存储的无序的集合，通过键来找到值，但是键是 以hash算法来存储的无序集合。
TreeSet:
TreetSet是SortSet接口的实现类，TreeSet可以保证元素处于排序状态再保存。它采用的是红黑树算法数 据结构来存储集合元素。TreeSet支持两种排序：自然排序和定制排序，默认采用自然排序
自然排序：
package SetTest;
import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {
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 (Integer val:tre){
System.out.println(val);
}
}
}输出：
1
3
4
5
8
定制排序：
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);
}
}
}输出：（会按照输入的顺序去读值）
40
20
10
30
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]
这些就是常用的集合代码举例，大家可以结合上一章的理论知识来看，在这里写的都是一些很简洁的例子，大家多看看就可以理解。
加载全部内容