Java根底(十一)

2018-03-02 08:31:47来历:cnblogs.com作者:ZT1994人点击

共享

一、调集结构

1、调集结构界说

  调集结构是一个用来代表和操作调集的共同架构。一切的调集结构都包括如下内容:

  • 接口:是代表调集的抽象数据类型。接口答应调集独立操作其代表的细节。在面向目标的言语,接口一般构成一个层次。
  • 完成(类):是调集接口的详细完成。从本质上讲,它们是可重复运用的数据结构。
  • 算法:是完成调集接口的目标里的办法履行的一些有用的核算,例如:查找和排序。这些算法被称为多态,那是由于相同的办法能够在相似的接口上有着不同的完成。

除了调集,该结构也界说了几个Map接口和类。Map里存储的是键/值对。虽然Map不是collections,可是它们彻底整合在调集中。

二、List 接口

1、ArrayList 的运用

ArrayList 是一个调集容器类。

1、ArrayList 的结构办法

2、 ArrayList 办法

  测验ArrayList:

 1 import org.junit.Test; 2  3 import java.util.ArrayList; 4 import java.util.Iterator; 5 import java.util.ListIterator; 6  7 public class ArrayListTest { 8  9     /**10      * 测验ArrayList11      */12     @Test13     public void test() {14         ArrayList<Object> list = new ArrayList<>();15 16         list.add("test1");17         list.add("test2");18         list.add("test3");19         list.add("test4");20 21         list.add(1, "test5"); //刺进 1 是索引22         System.out.println(list);  //[test1, test5, test2, test3, test4]  打印出值,由于ArrayList覆写了 toString办法23         System.out.println("size:" + list.size());  //size:524 25         //遍历ArrayList 1、一般for循环26         for (int i = 0; i < list.size(); i++) {27             System.out.println(" list = " + list.get(i));28         }29         System.out.println("=======");30         for (Object o : list) {  //2、增强for循环31             System.out.println(" list = " + o);32         }33         System.out.println("=======");34         //3.迭代器遍历ArrayList35         Iterator<Object> iterator = list.iterator();36         while (iterator.hasNext()) {37             System.out.println(" list = " + iterator.next());38         }39         System.out.println("=======");40         //ListIterator迭代41         ListIterator<Object> listIterator = list.listIterator();42         while (listIterator.hasNext()) {43             System.out.println(" list = " + listIterator.next());44         }45         System.out.println("=======");46         while (listIterator.hasPrevious()) {47             //反向打印,次序相反48             System.out.println(" list = " + listIterator.previous());49         }50     }51 }

2、LinkedList 运用

  依据链表结构的调集 LinkedList。LinkedList 归于 java.util 包下面,也完成Iterable接口,阐明能够运用迭代器遍历;LinkedList 还完成 Deque<E>,Queue<E> 操作。Deque 和 Queue 是 LinkedList 的父接口,那么 LinkedList 也能够当作一种 Deque 或许 Queue;Queue表明一种行列,也是一种数据结构,它的特色是先进先出,因此在行列这个接口里边供给了一些操作行列的办法,一起LinkedList也具有这些办法;Deque(Double ended queues双端行列),支撑在两头刺进或许移除元素; 那也应该具有操作双端行列的一些办法;LinkedList 是他们的子类,阐明都具有他们两者的办法;LinkedList也能够充任行列,双端行列,仓库多个人物。

1、 LinkedList 结构办法

2、 LinkedList 办法

  测验 LinkedList:

 1 import org.junit.Test; 2  3 import java.util.LinkedList; 4  5 public class LinkedListTest { 6  7     /** 8     * 测验LinkedList 9      ArrayList : 依据数组,能够重复,有索引,记载增加次序(有序), 查找比较快;10      LinkedList: 依据链表,能够重复,有索引,记载增加次序(有序),增加删去比较快;多了一些操作头尾的办法,能够充任仓库,行列;11     */12     @Test13     public void test(){14         LinkedList<Object> linkedList = new LinkedList<>();15         linkedList.add("11");16         linkedList.add("22");17         linkedList.add("33");18         linkedList.add("44");19 20         System.out.println(linkedList);21         //遍历LinkedList22         for (int i = 0; i < linkedList.size(); i++) {23             System.out.println(linkedList.pop());24         }25         System.out.println(linkedList);26     }27 }

 3、 ArrayList 和 LinkedList 的差异

  ArrayList 和 LinkedList 都是线程不安全的。

  ArrayList 是 List 接口的一种完成,它是运用数组来完成的,即运用数组办法存储。

  LinkedList 是 List 接口的一种完成,它是运用链表来完成的,即运用双向链表完成存储。

  ArrayList 遍历和查找元素比较快。LinkedList 遍历和查找元素比较慢。

  ArrayList 增加、删去元素比较慢。LinkedList 增加、删去元素比较快。

三、set 接口

1、HashSet

   不能增加重复的元素,而且是无序的。

  HashSet判别是否相同的规矩: ①判别hashcode    ②判别equals ,假如两个目标的hashCode值持平,而且equals回来为true 就表明持平(重复)。

 1 import org.junit.Test; 2  3 import java.util.HashSet; 4  5 public class HashSetTest { 6     /** 7      * 测验HashSet 8      * 假如两个目标的hashCode值持平,而且equals回来为true 就表明持平(重复). 9      */10     @Test11     public void testHashSet() {12         HashSet<Object> hashSet = new HashSet<>();13         hashSet.add("11");14         hashSet.add("55");15         hashSet.add("22");16         hashSet.add("33");17         hashSet.add("44");18         hashSet.add("22");19 20         System.out.println(hashSet);  //[11, 55, 22, 33, 44] 和增加次序不相同21 22     }23 24     /**25      * 测验HashSet126      * HashSet特色:27      * ①不能增加重复元素,(经过调用目标的hashcode和equals);28      * ②无序(增加次序,和打印出来的次序并不相同);29      * <p>30      * 差异31      * HashSet :经过hashcode和equals判别重复;32      * TreeSet : 判别重复33      * ①运用元素的天然排序,(Comparable接口,运用其间的compareTo办法,回来0,表明持平,compareTo里边的参数只要一个);34      * ②运用比较器Comparator接口,其间的办法compare(Object o1,Object o2)回来0,表明持平35      */36     @Test37     public void testHashSet1() {38         HashSet set = new HashSet();39         Student s1 = new Student("悟空", 500);40         Student s2 = new Student("悟空", 500);41         set.add(s1);42         set.add(s2);43 44         System.out.println(set);  //[Student{name='悟空', age=500}]45     }46 }

  自界说类 Student :

 1 public class Student { 2     private String name; 3     private Integer age; 4  5     public Student(String name, Integer age) { 6         this.name = name; 7         this.age = age; 8     } 9 10     public String getName() {11         return name;12     }13 14     public void setName(String name) {15         this.name = name;16     }17 18     public Integer getAge() {19         return age;20     }21 22     public void setAge(Integer age) {23         this.age = age;24     }25 26 27     /**28      * 假定传入的目标也是student,依据事务目标的字段进行比较29      *30      * @param o31      * @return32      */33     @Override34     public boolean equals(Object o) {35         if (this == o) return true;36         if (o == null || getClass() != o.getClass()) return false;37 38         Student student = (Student) o;39 40         if (this.name.equals(student.getName()) && this.age == student.getAge()) {41             return true;42         } else {43             return false;44         }45     }46 47     @Override48     public int hashCode() {49         int result = name != null ? name.hashCode() : 0;50         result = 31 * result + (age != null ? age.hashCode() : 0);51         return result;52     }53 54     @Override55     public String toString() {56         return "Student{" +57                 "name='" + name + '/'' +58                 ", age=" + age +59                 '}';60     }61 }

2、TreeSet

  TreeSet 和 HashSet 许多方面也是相似的;特色和 HashSet 也是相同的;

  TreeSet 的特色:不能增加重复元素,无序的(不记载增加次序)。

2.1 TreeSet 排序

1、天然排序

  天然排序:此接口强行对完成它的每个类的目标进行全体排序,这种排序被称为类的天然排序。

  能够让类完成 Comparable 接口,经过 compareTo(Object obj) 办法,假如办法回来 0 表明持平,不然不等。

  完成了 Comparable 接口的 student 类:

 1 public class Student implements Comparable<Student> { 2     private String name; 3     private Integer age; 4  5     public Student(String name, Integer age) { 6         this.name = name; 7         this.age = age; 8     } 9 10     public String getName() {11         return name;12     }13 14     public void setName(String name) {15         this.name = name;16     }17 18     public Integer getAge() {19         return age;20     }21 22     public void setAge(Integer age) {23         this.age = age;24     }25 26 27     /**28      * 假定传入的目标也是student,依据事务目标的字段进行比较29      *30      * @param o31      * @return32      */33     @Override34     public boolean equals(Object o) {35         if (this == o) return true;36         if (o == null || getClass() != o.getClass()) return false;37 38         Student student = (Student) o;39 40         if (this.name.equals(student.getName()) && this.age == student.getAge()) {41             return true;42         } else {43             return false;44         }45     }46 47     @Override48     public int hashCode() {49         int result = name != null ? name.hashCode() : 0;50         result = 31 * result + (age != null ? age.hashCode() : 0);51         return result;52     }53 54     @Override55     public String toString() {56         return "Student{" +57                 "name='" + name + '/'' +58                 ", age=" + age +59                 '}';60     }61 62 63     /**64      * 覆写 compareTo65      *66      * @param s67      * @return68      */69     @Override70     public int compareTo(Student s) {71         if (this.age > s.getAge()) {72             return -1;73         } else if (this.age < s.getAge()) {74             return 1;75         } else {76             //return this.name.compareTo(s.getName()); 主动比较77             return 0;78         }79     }80 }

2、定制排序

  假如没有完成 Comparable 接口,需求自界说一个类,完成 Comparator 接口,覆写比较办法;

  比较器的完成:

 1 import java.util.Comparator; 2  3 /** 4  * 定制排序 5  */ 6 public class StudentComparator implements Comparator { 7     @Override 8     public int compare(Object o1, Object o2) { 9         Student s1 = (Student)o1;10         Student s2 = (Student)o2;11         if (s1.getAge() > s2.getAge()){12             return 1;13         }else if(s1.getAge() < s2.getAge()){14             return -1;15         }else {16             return 0;17         }18     }19 }

3、TreeSet 天然排序和定制排序的差异

  一般来说,先写一个比较规矩,让它完成 Comparable 接口,作为默许的比较规矩,假如不写比较器,则比较运用默许规矩,假如觉得默许比较规矩不够好,能够自己写个比较器,当经过存在默许比较规矩和比较器时,优先选择运用比较器,由于比较器更能满意需求。

  测验TreeSet:

 1 import org.junit.Test; 2  3 import java.util.TreeSet; 4  5 public class TreeSetTest { 6  7     /** 8      * 测验TreeSet 9      */10     @Test11     public void testTreeSet() {12         TreeSet<Object> treeSet = new TreeSet<>();13         treeSet.add("11");14         treeSet.add("33");15         treeSet.add("22");16         treeSet.add("44");17 18         System.out.println(treeSet);  //[11, 22, 33, 44]19     }20 21     @Test22     public void testTreeSet2() {23         TreeSet<Object> treeSet = new TreeSet<>();24         Student student1 = new Student("张", 8);25         Student student2 = new Student("张", 10);26         Student student3 = new Student("张", 7);27         Student student5 = new Student("张", 9);28         Student student4 = new Student("张", 11);29         treeSet.add(student3);30         treeSet.add(student4);31         treeSet.add(student2);32         treeSet.add(student1);33         treeSet.add(student5);34 35         System.out.println(treeSet);36     }37 38 39     /**40      * 测验比较器TreeSet41      */42     @Test43     public void testTreeSet3() {44         TreeSet<Object> treeSet = new TreeSet<>(new StudentComparator()); //优先选择比较器,假如选默许的,就不能满意要求呢;45         Student student1 = new Student("张", 8);46         Student student2 = new Student("张", 10);47         Student student3 = new Student("张", 7);48         Student student5 = new Student("张", 9);49         Student student4 = new Student("张", 11);50         treeSet.add(student3);51         treeSet.add(student4);52         treeSet.add(student2);53         treeSet.add(student1);54         treeSet.add(student5);55 56         System.out.println(treeSet);  57     }58 }

3、HashSet 和 TreeSet 总结

  HashSet特色:不重复,无序(经过 hashCode 办法和equals 办法,判别重复)。

  TreeSet 特色:不重复,无序(增加次序与打印次序不相同),可是打印次序依照必定规矩排序;排序有天然排序和定制排序。

四、Map 接口

  Map 简略了解成映射;

  Map:将键映射到值的目标。一个映射不能包括重复的键;每个键最多只能包括一个值。

1、hashMap

1、hashMap 的结构办法

2、hashMap 的办法

3、测验 hashMap

  详细测验:

 1 import org.junit.Test; 2  3 import java.util.*; 4  5 public class HashMapTest { 6     /** 7      * Map是什么? 8      * 简略了解成是映射; 9      * 判别重复的规范和HashSet共同,经过键的hashCode和equals;10      * 测验hashMap11      */12     @Test13     public void testHashMap() {14         Map<Object, Object> hashMap = new HashMap<>();15         hashMap.put("key1", "test1");  //存值16         hashMap.put("key2", "test2");17         hashMap.put("key2", "test3");18 19         System.out.println(hashMap);  //{key1=test1, key2=test3} 一个键只能有一个值,后边的值覆盖了前面的值20         System.out.println(hashMap.get("key1")); //取值 test121         System.out.println(hashMap.containsKey("key")); //判别是否包括这个键 false22         System.out.println(hashMap.containsValue("test"));  //判别是否包括着个值 false23 24         Map<Object, Object> hashMap1 = new HashMap<>();25         hashMap1.put("key3", "test3");26         hashMap1.put("key4", "test4");27         System.out.println(hashMap1);  //{key3=test3, key4=test4}28 29         hashMap.putAll(hashMap1); //将hashMap1的一切映射联络仿制到hashMap30         System.out.println(hashMap);  //{key1=test1, key2=test3, key3=test3, key4=test4}31         System.out.println(hashMap.size());  // 432 33         //遍历办法一:获取一切映射34         Set<Map.Entry<Object, Object>> entrySet = hashMap.entrySet();35         for (Map.Entry<Object, Object> entry : entrySet) {36             System.out.println("entry ==[" + entry);37         }38 39         //遍历办法二:获取一切键的调集40         Set<Object> keySet = hashMap.keySet();41         for (Object o1 : keySet) {42             //经过键回来值43             System.out.println("key = [" + o1 + "] ---> value = " + "[" + hashMap.get(o1) + "]" );44 45         }46     }47 }

2、Map小结

  HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。该类完成了Map 接口,依据键的 HashCode 值存储数据,具有很快的拜访速度,最多答应一条记载的键为null,不支撑线程同步

  Map接口

  HashMap 判别重复的规范和HashSet共同,经过键的 hashCode 和 equals;

  TreeMap  判别重复的规范和TreeSet共同,1:经过天然排序(Comparable 接口),2:定制排序(Compartor 比较器)。

五、调集算法 Collections

  彻底由在 collection 上进行操作或回来 collection 的静态办法组成。它包括在 collection 上操作的多态算法,即“包装器”,包装器回来由指定 collection 支撑的新 collection,以及少量其他内容。例如:查找和排序。

1、Collections 的办法

  上面是 Collections 类的一些常用办法,详细一切办法,能够自己检查API文档。

   测验 Collections 的一些常用办法:

 1 import org.junit.Test; 2  3 import java.util.ArrayList; 4 import java.util.Collections; 5 import java.util.List; 6  7 /** 8  * 测验collections 9  */10 public class CollectionsTest {11     @Test12     public void testCollections(){13         List list = new ArrayList();14 15         //addAll 将一切指定元素增加到指定 collection 中。16         Collections.addAll(list, 123, 456, false, null, "2333");17         System.out.println(list); //[123, 456, false, null, 2333]18 19         List list2 = new ArrayList();20         Collections.addAll(list2, 1, 1, 1, 1, 1, 2222222, 333333, "444444");21         Collections.copy(list2, list);  //仿制22         System.out.println(list2);  //[123, 456, false, null, 2333, 2222222, 333333, 444444]23 24         List list3 = new ArrayList();25         for (int i =0; i<10; i++){26             list3.add(i);27         }28         System.out.println("list3 "+ list3);  //list3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]29         Collections.shuffle(list3);  //乱序30         System.out.println("list3 " + list3);  //list3 [4, 1, 9, 7, 2, 6, 3, 8, 0, 5]31 32         System.out.println(Collections.max(list3));  //数组中最大值 933         Collections.sort(list3); //排序34         System.out.println(list3);  //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]35 36         Collections.fill(list3, 2);  // fill 运用指定元素替换指定列表中的一切元素。37         System.out.println(list3);  //[2, 2, 2, 2, 2, 2, 2, 2, 2, 2]38     }39 }

六、调集结构总结

1、List,Set,还有它们下面的子类都能够当作容器,都完成了超级的接口Collection;(检查API文档)

  List,Set 和Collection之间的联络是承继联络,由于接口与接口之后,只能是承继的联络。

2、ArrayList,LinkedList,HashSet,TreeSet 四个容器类的特色:

  ArrayList:完成 List 接口,依据数组,能够重复,有索引,记载增加次序,即有序,查找比较快。

  LinkedList:完成 List 接口,依据链表,能够重复,有索引,记载增加次序,即有序,增加删去比较快,多了一些操作头尾的办法,能够充任仓库,行列。

  HashSet:完成 Set 接口,不重复,无序(经过 hashCode 办法和equals 办法,判别重复)。

  TreeSet:完成 Set 接口,不重复,无序(增加次序与打印次序不相同),可是打印次序依照必定规矩排序;排序有天然排序和定制排序。①运用元素的天然排序,(Comparable 接口,运用其间的 compareTo 办法,回来0,表明持平,compareTo  里边的参数只要一个);②运用比较器 Comparator 接口,其间的办法 compare(Object o1,Object o2)回来0,表明持平。

3、Comparable 和 Comparator 的差异:

  Comparable 是一个比较的规范,里边有比较的办法,目标要具有比较的规范,就必须完成 Comparable 接口;类完成这个接口,就有比较的办法;把元素放到 TreeSet 里边去,就会主动的调用 CompareTo 办法;可是这个 Comparable  并不是专为 TreeSet 规划的;仅仅说,TreeSet 趁便使用罢了;就像 HashCode 和 equals  也相同,不是专门为 HashSet 规划相同;仅仅你趁便使用罢了。

  Compartor 是个比较器,也不是专门为TreeSet规划. 便是一个第三方的比较器接口;假如目标没有比较性,自己就能够依照比较器的规范,规划一个比较器,创立一个类,完成这个接口,覆写办法。

4、HashMap,TreeMap的特色:

  HashMap:完成 Map 接口,是一个散列表,它存储的内容是键值对(key-value)映射。依据键的 HashCode 值存储数据,具有很快的拜访速度,最多答应一条记载的键为null,不支撑线程同步。判别重复的规范和 HashSet 共同,经过键的 hashCode 和 equals。

  TreeMap:完成 Map 接口,判别重复的规范和TreeSet共同,1:经过天然排序(Comparable 接口),2:定制排序(Compartor 比较器)。

相关文章

    无相关信息

微信扫一扫

明升m88.com微信大众渠道