Übersicht über Java-Sammlungen
- 零下一度Original
- 2017-07-17 13:27:281365Durchsuche
1. Übersicht über Sammlungen
Es gibt viele Sammlungen in Java: List, ArrayList, Vector, HashSetTreeSet. Die Unterschiede zwischen ihnen, dem Framework von Java-Sammlungen usw. sind immer sehr vage Zeit, sie zusammenzufassen.
Wenn viele Daten gespeichert werden müssen und ein Container benötigt wird, die Anzahl der Daten jedoch ungewiss ist und Arrays nicht verwendet werden können, können Sie in Java einen anderen Container verwenden – a Sammlung, befindet sich in java.util.
1. Was ist der Unterschied zwischen einer Menge und einem Array?
① Die Länge des Arrays ist fest.
Die Länge der Sammlung ist variabel.
②Arrays speichern Elemente desselben Typs und können grundlegende Datentypwerte speichern.
Sammlungen speichern Objekte. Und die Objekttypen können inkonsistent sein.
2. Wann werden Sammlungen verwendet?
Wenn viele Objekte vorhanden sind, speichern Sie diese zuerst.
3. Rahmendiagramm des Sammlungssystems
2. Sammlungsschnittstelle
Sammlungsschnittstelle: die Stammschnittstelle eines einzelnen Spaltensammlungsklasse
🎜> ①Vector: Die Array-Struktur, die wachsen kann. synchron. Es ist sehr ineffizient und wurde durch ArrayList ersetzt. 
②ArrayList: Es handelt sich um eine Array-Struktur, die Länge ist variabel (Prinzip des Erstellens eines neuen Arrays + des Kopierens eines Arrays),
Die Abfragegeschwindigkeit ist sehr hoch
, das Hinzufügen und Löschen erfolgt langsam und asynchron. (Breite Anwendung). Beispiel:
Laufergebnis:
1 public class Example01 {
2 public static void main(String[] args) {
3 ArrayList list = new ArrayList(); //创建ArrayList集合
4 list.add("stu1");
5 list.add("stu2");
6 list.add("stu3");
7 list.add("stu4");
8 System.out.println("集合的长度："+list.size());//获得集合中元素的个数
9 System.out.println("集合的第二个元素："+list.get(1));//取出并打印指定位置的元素
10 }
11 }
集合的长度：4集合的第二个元素：stu2③LinktedList: Ja Linkstruktur,
Stack: First in Last Out FILO kann als Pistolenmagazin verstanden werden
Queue: First in First Out FILO kann als Warteschlange zum Kauf von Tickets verstanden werden Beispiele für gängige Methoden :
1 public class Example02 {
2 public static void main(String[] args) {
3 LinkedList link = new LinkedList();//创建LinkedList集合
4 link.add("stu1");
5 link.add("stu2");
6 link.add("stu3");
7 link.add("stu4");
8 System.out.println(link.toString());//取出元素并打印该集合中的元素
9 link.add(3,"Student"); //向该集合中的指定位置插入元素
10 link.addFirst("First"); //向该集合第一个位置插入元素
11 link.addLast("Last"); //向该集合第一个位置插入元素
12 System.out.println(link);
13 System.out.println(link.getFirst()); //取出该集合第一个元素
14 System.out.println(link.getLast()); //取出该集合最后一个个元素
15 link.remove(3); //移除该集合中指定位置的元素
16 link.removeFirst(); //移除该集合中第一个元素
17 link.removeLast(); //移除该集合中最后一个个元素
18 System.out.println(link);
19 }
20 } 2. Iterator-Schnittstelle
So rufen Sie die Sammlung ab:
[stu1, stu2, stu3, stu4] [First, stu1, stu2, stu3, Student, stu4, Last] First Last [stu1, stu2, Student, stu4]
① Erstellen Sie ein Sammlungsobjekt
while (it.hasNext()){
System.out.println(it.next());
} Dieser Iterator kann die Array-Elemente während des Iterationsprozesses nicht ändern, da sonst eine gleichzeitige Änderungsausnahme (ConcurrentModificationException) auftritt.
3. foreach:
Format:
Was ist der Unterschied zwischen der alten for-Schleife? for（Iterator it = coll.iterator();it.hasNext();）{
System.out.println(it.next());
} ist eigentlich eine erweiterte for-Schleife. Sie wird zum Durchlaufen von Sammlungen und Arrays verwendet. Hinweis: Die neue for-Schleife muss ein zu durchlaufendes Ziel haben. Das Ziel kann nur eine Sammlung oder ein Array sein.
Vorschlag: Wenn Sie das Array nur zum Durchlaufen verwenden, können Sie „Enhanced for“ verwenden. Wenn Sie die Elemente des Arrays bearbeiten möchten, verwenden Sie die altmodische for-Schleife, um die Indizes zu durchlaufen . for（元素数据类型 变量 ：collection集合or数组（））{执行语句}
Beispiel:
Laufendes Ergebnis:
1 public class Foreach {
2 static String [] strs = {"aaa","bbb","ccc"};
3 public static void main(String[] args) {
4 //foreach循环遍历数组
5 for(Object obj : strs){
6 System.out.println(obj);
7 }
8 System.out.println("______________");
9 //foreach循环遍历数组并修改（修改失败）
10 for (String str : strs){
11 str="ddd";
12 }
13 System.out.println("foreach循环修改后的数组："+strs[0]+","+strs[1]+","+strs[2]);
14 //for循环遍历数组
15 for(int i = 0;i<strs.length;i++){
16 strs[i]="ddd";
17 }
18 System.out.println("普通for循环修改后的数组："+strs[0]+","+strs[1]+","+strs[2]);
19 }
20 }4 Iterator
Iterator的子类，该列表迭代只有List接口有，而且这个迭代器可以完成在迭代过程中的增删改查动作。
add方法示例：
1 public class AddDemo {
2 public static void main(String[] args) {
3
4 //在最前面添加
5 List<String> list1 = new LinkedList<String>(Arrays.asList(
6 new String[] { "a", "b", "c" }));
7 ListIterator<String> listIterator1 = list1.listIterator();
8 listIterator1.add("D");
9 listIterator1.add("E");
10 System.out.println(list1);//[D, E, a, b, c]
11 //在最后面添加
12 List<String> list2 = new LinkedList<String>(Arrays.asList(
13 new String[] { "a", "b", "c" }));
14 ListIterator<String> listIterator2 = list2.listIterator();
15 while (listIterator2.hasNext()) {
16 listIterator2.next();
17 }
18 listIterator2.add("D");
19 listIterator2.add("E");
20 System.out.println(list2);//[a, b, c, D, E]
21 //在每个元素的前面和后面都添加
22 List<String> list3 = new LinkedList<String>(Arrays.asList(
23 new String[] { "a", "b", "c" }));
24 ListIterator<String> listIterator3 = list3.listIterator();
25 while (listIterator3.hasNext()) {
26 listIterator3.add("前面");
27 listIterator3.next();
28 listIterator3.add("后面");
29 }
30 System.out.println(list3);//[前面, a, 后面, 前面, b, 后面, 前面, c, 后面]
31 //在指定元素的前面和后面添加
32 List<String> list4 = new LinkedList<String>(Arrays.asList(
33 new String[] { "a", "b", "c" }));
34 ListIterator<String> listIterator4 = list4.listIterator();
35 while (listIterator4.hasNext()) {
36 if (listIterator4.next().equals("a")) {//现在指向的是a的后面
37 listIterator4.previous();//先重新指向a的前面，这里不用担心NoSuchElementException
38 listIterator4.add("前面");//在前面添加元素，添加后还是指向的a的前面
39 listIterator4.next();//向后【再】移动一位，现在指向的是a的后面
40 listIterator4.add("后面");//在a的后面添加元素
41 }
42 }
43 System.out.println(list4);//[前面, a, 后面, b, c]
44 }
45 }remove方法示例：
1 public class RemoveDemo {
2 public static void main(String[] args) {
3
4 // 执行next()或previous()后不能先执行了 add()方法。
5 // 因为add()方法执行以后，迭代器已经移动了，这样所要删除的目标元素指向不明，会报异常。
6 //标准的做法：在next之后才能remove
7 List<String> list2 = new LinkedList<String>(Arrays.asList(
8 new String[] { "b", "a", "b", "c", "b", }));
9 ListIterator<String> listIterator2 = list2.listIterator();
10 while (listIterator2.hasNext()) {
11 if (listIterator2.next().equals("b")) {listIterator2.remove();}
12 }
13 System.out.println(list2);//[a, c]
14
15 //移除指定范围内的所有元素
16 List<String> list3 = new LinkedList<String>(Arrays.asList(
17 new String[] { "a", "开始", "b", "c", "d", "结束", "e" }));
18 ListIterator<String> listIterator3 = list3.listIterator();
19 while (listIterator3.hasNext()) {
20 if (listIterator3.next().equals("开始")) {
21 listIterator3.remove();//注释掉这行代码则不移除"开始"
22 while (listIterator3.hasNext()) {
23 if (!listIterator3.next().equals("结束")) {
24 listIterator3.remove();//remove之后必须再调用next方法后才能再remove
25 } else {
26 listIterator3.remove();//注释掉这行代码则不移除"结束"
27 break;//结束while循环
28 }
29 }
30 }
31 }
32 System.out.println(list3);//[a, e]
33 //替换指定元素
34 List<String> list5 = new LinkedList<String>(Arrays.asList(
35 new String[] { "a", "b", "c" }));
36 ListIterator<String> listIterator5 = list5.listIterator();
37 while (listIterator5.hasNext()) {
38 if (listIterator5.next().equals("b")) {
39 listIterator5.remove();
40 listIterator5.add("替换");
41 }
42 }
43 System.out.println(list5);//[a, 替换, c]
44 }
45 }5、Set接口
不包含重复元素的集合，不保证顺序。而且方法和Collection一致。Set集合取出元素的方式只有一种：迭代器。
①HashSet：哈希表结构，不同步，保证元素唯一性的方式依赖于： hashCode（），equals（）方法。查询速度快。哈希值是根据存储位置来计算。
1 class Student{
2 private String id;
3 private String name;
4 public Student(String id,String name){
5 this.id = id;
6 this.name = name;
7 }
8 // 重写toString方法
9 public String toString(){
10 return id+":"+name;
11 }
12 // 重写hashCode方法
13 public int hashCode(){
14 return id.hashCode();//返回id属性的哈希值
15 }
16 // 重写equals方法
17 public boolean equals(Object obj){
18 if(this==obj){ //判断是否为同一个对象
19 return true; //如果是，直接返回true
20 }
21 if (!(obj instanceof Student)){ //判断对象是否Student类型
22 return false; //如果对象不是Student类型，返回false
23 }
24 Student stu = (Student)obj; //将对象强转为Student类型
25 boolean b= this.id.equals(stu.id); //判断id值是否相同
26 return b; //返回判断结果
27 }
28 }
29 public class HashSetDemo {
30 public static void main(String[] args) {
31 HashSet set = new HashSet();
32 Student stu1= new Student("1","Jack");
33 Student stu2= new Student("2","Rose");
34 Student stu3= new Student("2","Rose");
35 set.add(stu1);
36 set.add(stu2);
37 set.add(stu3);
38 System.out.println(set);
39 }
40 }运行结果：
[1:Jack, 2:Rose] 若不重写hashCode()和equals（）方法，则输出结果是： [2:Rose，1:Jack, 2:Rose]
②TreeSet：可以对Set集合中的元素进行排序。使用的是二叉树结构。如何保证元素唯一性的？使用的是对象比较方法的结果是否为0，是0，视为相同元素不存。
元素的排序比较有两种方式：
元素自身具备自然排序，其实就是实现了Comparable接口重写compareTo方法。如果元素自身不具备自然排序，或具备的自然排序不是所需要的，这时只能用第二种方式。
比较器，其实就是在创建TreeSet集合时，在构造函数中指定具体的比较方式。需要定义一个类实现Comparator接口，重写compare方法。
-
1 class Student implements Comparable{ //定义Student类实现Comparable接口 2 String name; 3 int age; 4 public Student(String name,int age){ //创建构造方法 5 this.name = name; 6 this.age = age; 7 } 8 public String toString(){ //重写Object类toString（）方法，返回描述信息 9 return name+":"+age; 10 } 11 public int compareTo(Object obj){ //重写Comparable接口compareTo方法 12 Student s =(Student) obj; //将比较对象强转为Student类型 13 if (this.age -s.age>0){ //定义比较方法 14 return 1; 15 } 16 if (this.age-s.age==0){ 17 return this.name.compareTo(s.name);//将比较结果返回 18 } 19 return -1; 20 } 21 } 22 public class TreeSetDemo { 23 public static void main(String[] args) { 24 TreeSet ts = new TreeSet(); 25 ts.add(new Student("Jack",19)); 26 ts.add(new Student("Rose",18)); 27 ts.add(new Student("Tom",19)); 28 ts.add(new Student("Rose",18)); 29 Iterator it = ts.iterator(); 30 while (it.hasNext()){ 31 System.out.println(it.next()); 32 } 33 } 34 } 运行结果： Rose:18 Jack:19 Tom:19到此为止：在往集合中存储对象时，通常该对象都需要覆盖hashCode，equals，同时实现Comparable接口，建立对象的自然排序。通常还有一个方法也会复写toString();
三、Map接口：
双列集合Map集合的特点：内部存储的都是键key值value对，必须要保证键的唯一性。
Map集合常用方法
①Hashtable---数据结构：哈希表。是同步的，不允许null作为键和值。被HashMap替代。
子类Properties：属性表，键和值都是字符串，而且可以结合流进行键值操作。唯一一个可以和IO流结合使用的集合类。
②HashMap---数据结构：哈希表。不是同步的，允许null作为键和值。
示例：
1 public class Example15 {
2 public static void main(String[] args){
3 Map map = new HashMap(); //创建Map对象
4 map.put("1","Jack"); //存储键和值，键相同，值覆盖
5 map.put("2","Rose");
6 map.put("3","Lucy");
7 map.put("3","Mary");
8 System.out.println("1:"+map.get("1"));//根据键获取值
9 System.out.println("2:"+map.get("2"));
10 System.out.println("3:"+map.get("3"));
11 }
12 }Map集合的两种遍历方式：
1 public class Example16 {
2 public static void main(String[] args){
3 //第一种先遍历Map集合中所有的键，再跟据键获取相应的值。
4 Map map1 = new HashMap(); //创建Map对象
5 map1.put("1","Jack"); //存储键和值
6 map1.put("2","Rose");
7 map1.put("3","Lucy");
8 Set keySet1 = map1.keySet(); //获取键的集合
9 Iterator it1 = keySet1.iterator();
10 while (keySet1.iterator().hasNext()){ // 迭代键的集合
11 Object key = it1.next();
12 Object value = map1.get(key); //获得每个键所对应的值
13 System.out.println(key+":"+value);
14 }
15
16 //第二种先获取集合中的所有映射关系，然后从映射关系中取出键和值
17 Map map2 = new HashMap();
18 map2.put("1","Jack"); //存储键和值
19 map2.put("2","Rose");
20 map2.put("3","Lucy");
21 Set entrySet = map2.entrySet();
22 Iterator it = entrySet.iterator(); //获取Iterator对象
23 while (it.hasNext()){
24 Map.Entry entry = (Map.Entry)(it.next()); //获取集合中键值对映射关系
25 Object key = entry.getKey(); //获取Entry中的键
26 Object value = entry.getValue(); //获取Entry中的值
27 System.out.println(key+":"+value);
28 }
29 }
30 }运行结果：
1:Jack 2:Rose 3:Lucy
LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。
③TreeMap---数据结构：二叉树，保证键的唯一性，同步的，可以对map集合中的键进行排序。
1 //按学号从大排到小
2 public class Example20 {
3 public static void main(String[] args) {
4 TreeMap tm = new TreeMap(new MyCompartor()); //传入一个自定义比较器
5 tm.put("1","Jack"); //存储键和值
6 tm.put("2","Rose");
7 tm.put("3","Lucy");
8 Set keySet = tm.keySet(); //获取键的集合
9 Iterator it = keySet.iterator(); // 迭代键的集合
10 while (it.hasNext()){
11 Object key = it.next();
12 Object value = tm.get(key); //获得每个键所对应的值
13 System.out.println(key+":"+value);
14 }
15 }
16 }
17 class MyCompartor implements Comparator{ //自定义比较器
18 public int compare(Object o1, Object o2) { //实现比较方法
19 String id1 = (String) o1; //将Object类型的参数强转为String类型
20 String id2 = (String) o2;
21 return id2.compareTo(id1); //将比较结果之后的值返回，按字典相反顺序进行排序
22 }
23 }运行结果：
3:Lucy 2:Rose 1:Jack
四、 泛型（parameterized type）
1、泛型的使用
体现<数据类型>，<>也是括号，往括号里写都写其实就是在传递参数。
格式：ArrayList<参数化类型> list = new ArrayList<参数化类型>();
泛型的优点：安全机制；将运行时期的ClassCastExecption转移到了编译时期变成了编译失败。泛型技术，是给编译器使用的技术。避免了强转的麻烦。
示例：
1 public class Example23 {
2 public static void main(String[] args) {
3 ArrayList<String> list = new ArrayList<String>();
4 list.add("String");
5 list.add("Collection");
6 for(String str:list){
7 System.out.println(str);
8 }
9 }
10 }2、自定义泛型：
需求：请自己提供一个容器类。
分析：你要做一个容器类，你就应该知道容器类具备什么基本功能？
添加功能 save（）
获取功能 get（）
要做这样的方法，save是不是应该有参数呢？肯定的。
get（）应该有参数吗？这里我们可以不给形式参数，但是一定要有返回值类型。
基本格式：
void save （参数类型 参数）{…}
返回值类型 get（）{…..}
为了让我们的容器类能够存储任意类型的对象，我就应该给save（）方法中的参数定义为object类型。
当然，get（）方法的返回值类型应该是object类型。
出现问题：A 不兼容类型 B 类型转换异常
需求：自己定义一个泛型类并使用
如何定义一个泛型类呢？
就是把泛型安装其格式加在类上。
格式：
<参数化类型>可以是E、T这样有意义的单词。
使用泛型后，我们可以不用再做类型转换了。
//在创建类时，声明参数类型为T
class 类名<T>{
T temp;
//在创建save（）方法时，指定参数类型为T
public void save (T temp){this.temp = temp}
//在创建get()方法时，指定返回值类型为T
public T get(){
return temp；
}
}示例：
1 class CachePool<T>{
2 T temp;
3 public void save(T temp){
4 this.temp=temp;
5 }
6 public T get() {
7 return temp;
8 }
9 }
10 public class Example26 {
11 public static void main(String[] args) {
12 CachePool<Integer> pool = new CachePool<Integer>();
13 pool.save(new Integer(1));
14 Integer temp = pool.get();
15 System.out.println(temp);
16 }
17 }五、Collections工具类
Collections：集合框架中的用于操作集合对象工具类。都是静态方法。
获取Collection最值。
对List集合排序，也可以用二分查找。
对排序逆序。
可以将非同步的集合转变成同步的集合。如：Xxx synchronizedXxx(Xxx) -------List synchronizedList (List)
//排序操作
1 public class Example27 {
2 public static void main(String[] args) {
3 ArrayList list = new ArrayList();
4 Collections.addAll(list,"c","z","B","K");
5 System.out.println("排序前："+list);
6 Collections.reverse(list);
7 System.out.println("反转后："+list);
8 Collections.shuffle(list);
9 System.out.println("按自然顺序排序后："+list);
10 Collections.sort(list);
11 System.out.println("洗牌后："+list);
12 }
13 }运行结果：
排序前：[c, z, B, K] 反转后：[K, B, z, c] 按自然顺序排序后：[c, B, K, z] 洗牌后：[B, K, c, z]
<br>
//查找、替换操作
1 public class Example28 {
2 public static void main(String[] args) {
3 ArrayList list = new ArrayList();
4 Collections.addAll(list,-3,2,9,5,8);
5 System.out.println("集合中的元素："+list);
6 System.out.println("集合中的最大元素："+Collections.max(list));
7 System.out.println("集合中的最小元素："+Collections.min(list));
8 Collections.replaceAll(list,8,0); //将集合中的8用0替换掉
9 System.out.println("替换后的集合："+list);
10 }
11 }
运行结果：
集合中的元素：[-3, 2, 9, 5, 8] 集合中的最大元素：9集合中的最小元素：-3替换后的集合：[-3, 2, 9, 5, 0]
六、Arrays：用于操作数组的工具类。类中定义的都是静态工具方法。
对数组排序。
二分查找。
数组复制。
对两个数组进行元素的比较，判断两个数组是否相同。
-
将数组转成字符串。
1 //使用Arrays的sort()方法排序 2 public class Example29 { 3 public static void main(String[] args) { 4 int[] arr={9,8,3,5,2}; 5 System.out.print("排序前："); 6 printArray(arr); 7 Arrays.sort(arr); 8 System.out.print("排序后："); 9 printArray(arr); 10 } 11 public static void printArray(int[] arr) { 12 System.out.print("["); 13 for (int x=0;x<arr.length;x++){ 14 if (x!=arr.length-1){ 15 System.out.print(arr[x]+","); 16 }else { 17 System.out.println(arr[x]+"]"); 18 19 } 20 } 21 } 22 }排序前：[9,8,3,5,2]<br>排序后：[2,3,5,8,9]
-
1 //使用Arrays的binarySearch（Object[] a,Object key）方法查找元素 2 class Example { 3 public void run() { 4 int[] arr={9,8,3,5,2}; 5 Arrays.sort(arr);//调用排序方法，对数组排序 6 int index = Arrays.binarySearch(arr,3);//查找指定元素3 7 System.out.println("数组排序后元素3的索引是："+index);//输出打印元素所在的索引位置 8 } 9 } 数组排序后元素3的索引是：1 -
1 //使用Arrays的copyOfRange(int[] original,int from,int to)方法拷贝元素 2 class Example31 { 3 public void run() { 4 int[] arr={9,8,3,5,2}; 5 int[] copies=Arrays.copyOfRange(arr,1,7); 6 for (int i =0;i<arr.length;i++){ 7 System.out.print(copies[i]+","); 8 } 9 } 10 } 【8,3,5,2,0,0】1 //使用Arrays的fill（Object[] a,Object val）方法填充元素 2 class Example{ 3 public void run() { 4 int[] arr={1,2,3,4}; 5 Arrays.fill(arr,8); 6 for (int i =0;i<arr.length;i++){ 7 System.out.print(i+":"+arr[i]+“---”); 8 } 9 } 10 } 0:8---1:8---2:8---3:81 //使用Arrays的toString(int [] ,arr)方法把数组转换为字符串 2 class Example{ 3 public void run() { 4 int[] arr={9,8,3,5,2}; 5 String arrString=Arrays.toString(arr); //使用toString()方法将数组转换为字符串 6 System.out.println(arrString); 7 } 8 }[9, 8, 3, 5, 2]
6、数组转成list集合——asList() 。
数组转成集合：就是为了使用集合的方法操作数组中的元素。
但是不要使用增删等改变长度的方法。add remove 发生UnsupportedOperationException
如果数组中存储的是基本数据类型，那么转成集合，数组对象会作为集合中的元素存在。数组中元素是引用数据类型时，转成，数组元素会作为集合元素存在。
7、集合转成数组——toArray().
为什么集合转成数组呢？
为了限制对元素的增删操作。
如果传递的数组的长度小于集合的长度，会创建一个同类型的数组长度为集合的长度。
如果传递的数组的长度大于集合的长度，就会使用这个数组，没有存储元素的位置为null。
长度最好直接定义为何集合长度一致。
Das obige ist der detaillierte Inhalt vonÜbersicht über Java-Sammlungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Stellungnahme：
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel：Java-LernprozessNächster Artikel：Java-Lernprozess