java：容器/集合Collection（List（ArrayList，LinkedList，Vector），Set（HashSet（LinkedHashSet），TreeSet））
/**
* Collection接口 不唯一，无序
* 常用的方法:
* add(Object e) 确保此 collection 包含指定的元素（可选操作）。
* size():获取集合中元素的个数
* remove(Object e):移除元素
* clear():清空集合中元素
* contains(Object e):判断集合中是否包含指定的元素
* isEmpty():判断集合是否为空
* iterator():获取集合对应的迭代器。
* --List接口:不唯一,有序(插入顺序)
* ----ArrayList类:可变长度的数组,本质上是通过数组实现的，在内存中存储空间是连续
* ------优点:随机访问或遍历时效率较高
* ------缺点:插入和删除时需要大量对元素的位置进行移动，效率较低。
* ArrayList常用的构造方法
* ArrayList() 构造一个初始容量为 10 的空列表。
* ArrayList(int initialCapacity) 构造一个具有指定初始容量的空列表。
* 常用的方法:
* add(Object e):将元素添加到集合中。
* add(int index, E element) 将指定的元素插入此列表中的指定位置。
* get(int index) 返回此列表中指定位置上的元素。下标从0开始
* --Set接口:唯一,无序
* Map接口:采用键值对进行存储。
*/
import java.util.ArrayList; import java.util.List; public class TestArrayList { public static void main(String[] args) { // Collection list = new ArrayList(); List list = new ArrayList(); //添加元素 list.add("aa"); list.add("bb"); list.add("cc"); list.add(2,"dd"); //遍历输出 for(int i=0;i<list.size();i++){ String string =(String)list.get(i); System.out.println(string); } } }
*java.util.ArrayList类
*add(Object obj):添加元素
*Object get(int index):获取指定下标位置的元素.
*注意:在调用add方法添加元素时，该元素会向上转型为Object类型，所有使用get方法获取是返回值为Object
import java.util.ArrayList; import java.util.List; public class TestArrayList2 { public static void main(String[] args) { Student student = new Student("zhangsan",20); Student student2 = new Student("zhangsan2",22); Student student3 = new Student("zhangsan3",24); List list = new ArrayList(); list.add(student); list.add(student2); list.add(student3); //遍历输出 for(int i=0;i<list.size();i++){ Student stu=(Student)list.get(i);//强制转换 System.out.println(stu.getName()+"---"+stu.getAge()); } System.out.println("-----------"); for(Object obj:list){ Student stu = (Student)obj; System.out.println(stu.getName()+"---"+stu.getAge()); } } }
* java.util.Iterator接口：对 collection 进行迭代的迭代器。
* boolean hasNext() 如果仍有元素可以迭代，则返回 true。
* E next() 返回迭代的下一个元素。
public class Student { private String name; private int age; public Student(){ } public Student(String name,int age){ this.name=name; this.age=age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class TestIterator { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("zhang"); list.add("wang"); list.add("li"); list.add("zhao"); //使用迭代器进行遍历 Iterator<String> iter = list.iterator(); //判断是否还有下一个元素可迭代 while(iter.hasNext()){ String str = iter.next();//获取下一个元素 System.out.println(str); } System.out.println("---------老外习惯用for进行迭代--------"); for(Iterator<String> iter2=list.iterator();iter2.hasNext();){ String str2 = iter2.next(); System.out.println(str2); } } }
* 泛型:限定集合中元素的类型。一旦对集合使用泛型，该集合中能容纳的元素类型就固定了。
* 语法:List<E> list = new ArrayList<E>();
* 优点:1.可以避免强制转换
* 2.可以消除黄色的警告。
import java.util.ArrayList; import java.util.List; public class TestArrayList3 { public static void main(String[] args) { Student student = new Student("zhangsan",20); Student student2 = new Student("zhangsan2",22); Student student3 = new Student("zhangsan3",24); List<Student> list = new ArrayList<Student>(); list.add(student); list.add(student2); list.add(student3); // list.add(123); // list.add("abc"); //遍历输出 for(int i=0;i<list.size();i++){ Student stu=list.get(i);//使用泛型后不需要强制转换 System.out.println(stu.getName()+"---"+stu.getAge()); } System.out.println("-----------"); for(Student stu:list){ System.out.println(stu.getName()+"---"+stu.getAge()); } } }
* List接口
* ----ArrayList类:在内存中存储位置是连续的，线性结构(可变长度的数组),随机访问或遍历效率较高,但插入和删除元素效率较低.
* ----LinkedList类:在内存中存储位置是不连续的，链表结构，插入和删除元素时效率较高,但随机访问或遍历效率较低。
* 常用方法:
* add(Object o):将指定元素添加到此列表的结尾。
* add(int index, E element)在此列表中指定的位置插入指定的元素。
* addFirst(E e) 将指定元素插入此列表的开头。(LinkedList特有的)
* addLast(E e)将指定元素添加到此列表的结尾。(LinkedList特有的)
* getFirst() 返回此列表的第一个元素。
* getLast() 返回此列表的最后一个元素。
* removeFirst() 移除并返回此列表的第一个元素。
* removeLast() 移除并返回此列表的最后一个元素。
LinkedList
public class TestLinkedList { public static void main(String[] args) { // List list = new LinkedList(); LinkedList<String> linkedList = new LinkedList<String>(); linkedList.add("java"); linkedList.add("oracle"); linkedList.addFirst("c"); linkedList.addLast("html"); linkedList.removeFirst();//移除第一个元素 linkedList.removeLast();//移除最后一个元素 //方法1:通过下标进行遍历 for (int i = 0; i < linkedList.size(); i++) { String str = linkedList.get(i); System.out.println(str); } System.out.println("-------------"); //方法2:通过foreach进行遍历 for (String string : linkedList) { System.out.println(string); } System.out.println("-------------"); //方法3:通过iterator进行遍历 Iterator<String> iter = linkedList.iterator(); while(iter.hasNext()){ String string = iter.next(); System.out.println(string); } } }
模拟进栈出栈：
进出统一。
*栈LIFO/FILO:后进先出(Last In First Out),先进后出(First In Last Out)
* 类似于玩具枪的弹夹，第一个压进去的子弹最后一个弹出
*入栈(压栈):将元素添加到栈中。
*出栈(弹栈):将元素从栈的顶部移除。
*队列FIFO:先进先出(First In First Out)
public class MyStack { LinkedList linkedList = new LinkedList(); //入栈:将新元素添加到最后 public void push(Object obj){ // linkedList.addLast(obj); linkedList.addFirst(obj); } //出栈: public Object pop(){ // Object obj = linkedList.removeLast(); Object obj = linkedList.removeFirst(); return obj; } public static void main(String[] args) { MyStack stack = new MyStack(); stack.push("aa"); stack.push("bb"); stack.push("cc"); Object obj = stack.pop(); System.out.println(obj); Object obj2 = stack.pop(); System.out.println(obj2); Object obj3 = stack.pop(); System.out.println(obj3); } }
Vector：
* ---ArrayList:线性结构，非线程安全，效率较高，随机访问或遍历时效率较高，添加和删除时效率较低
* ---Vector:线性结构，与ArrayList相似，Vector是线程安全的用在多线程程序中,相比ArrayList效率较低。
* ---LinkedList:链表结构,添加和删除时效率较高，随机访问或遍历时效率较低
import java.util.List;
import java.util.Vector;
public class TestVector { public static void main(String[] args) { List<String> vector = new Vector<String>(); vector.add("java"); vector.add("oracle"); vector.add("mysql"); for (String string : vector) { System.out.println(string); } } }
Set:
*Set接口:无序，唯一(不重复)
*----HashSet:采用hash表(散列表)方式进行存储数据。
* 优点:查询，添加，删除速度较快。
* 缺点:无序(添加顺序)
*常用的构造方法:
* HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
* HashSet(int initialCapacity) 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
*常用的方法:
* add(E e)如果此 set 中尚未包含指定元素，则添加指定元素。
* clear() 从此 set 中移除所有元素。
* contains(Object o) 如果此 set 包含指定元素，则返回 true。
* iterator() 返回对此 set 中元素进行迭代的迭代器。
* size()返回此 set 中的元素的数量（set 的容量）。
* remove(Object o)如果指定元素存在于此 set 中，则将其移除。
public class TestHashSet { public static void main(String[] args) { Set<String> set = new HashSet<String>(); set.add("java"); set.add("mysql"); set.add("html"); set.add("java");//添加时会去掉重复项 System.out.println("共有"+set.size()+"个元素"); //遍历1:通过for-each遍历 for(String str:set){ System.out.println(str); } System.out.println("---------------"); Iterator<String> iter = set.iterator(); while(iter.hasNext()){ String str = iter.next(); System.out.println(str); } } }
*如果向set结合添加对象时，想将内容相同的重复项去掉，需要重写hashCode()和equals()
*hashCode()和equals()的关系
*在向Set集合中添加元素时 ，先调用hashCode()方法获取当前对象的hash码,
*根据对象的hash码与集合中对象的hash码进行比较,如果hash码相同在调用equals()方法进行比较内容是否相同。
*如果hash码不同，将不再调用equals方法。
*如果equals相同，hash码肯定相同;hash码相同，equals结果不一定相同。
public class Student { private String name; private int age; public Student(){ } public Student(String name,int age){ this.name=name; this.age=age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } /** * 重写Object中的hashCode方法 */ @Override public int hashCode() { System.out.println("hashCode....."); final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } /** * 重写Object中equals方法:用于比较两个对象的内容是否相同 */ @Override public boolean equals(Object obj) { System.out.println("equals....."); if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass())//类型不同 return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
import java.util.HashSet; import java.util.Set; public class TestHashSet2 { public static void main(String[] args) { Student stu1 = new Student("zhangsan",20); Student stu2 = new Student("zhangsan2",22); Student stu3 = new Student("zhangsan",20); Set<Student> set = new HashSet<Student>(); set.add(stu1); set.add(stu2); set.add(stu3); for (Student student : set) { System.out.println(student.getName()+"---"+student.getAge()); } } }
LinkedHashSet:
*Set接口:唯一，无序(插入顺序)
*--HashSet:采用的哈希表的方式进行存储
*----LinkedHashSet:哈希表+链表结构进行存储。有序(添加顺序)。
*常用的构造方法
*LinkedHashSet() 构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set
*LinkedHashSet(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。
*常用的方法:
* add(Object a):添加元素
* remove(Object a):移除指定的元素
* contains(Object a):是否包含指定的元素
* size():获取元素的个数。
* iterator():返回一个迭代器
import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; public class TestLinkedHashSet { public static void main(String[] args) { Set<String> set = new LinkedHashSet<String>(); set.add("java"); set.add("struts"); set.add("hibernate"); set.add("spring"); // System.out.println(set); for (String string : set) { System.out.println(string); } System.out.println("-----------------"); Iterator<String> iter = set.iterator(); while(iter.hasNext()){ String string = iter.next(); System.out.println(string); } } }
TreeSet:
* TreeSet类:采用的二叉树(红黑树)的方式存储，有序(大小顺序|自然顺序)。
* 原理:当向TreeSet容器添加元素时，会将当前元素的值与根节点/父节点的值进行比较，
* 如果比根节点/父节点的值大，保存在右子节点上。
* 如果比根节点/父节点的值小，保存在左子节点上。
* 优点:有序，查询速度比List要快(折半查找)。
* 常用的构造方法:
* TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
* TreeSet(Comparator<? super E> comparator)构造一个新的空 TreeSet，它根据指定比较器进行排序。
* 常用的方法:
* add(Object o):添加元素
* remove(Object o):移除元素
* contains(Object o) 如果此 set 包含指定的元素，则返回 true。
* size():返回 set 中的元素数（set 的容量）。
* iterator():返回在此 set 中的元素上按升序进行迭代的迭代器
import java.util.Iterator; import java.util.Set; import java.util.TreeSet; public class TestTreeSet { public static void main(String[] args) { Set<Integer> treeSet=new TreeSet<Integer>(); treeSet.add(3); treeSet.add(13); treeSet.add(1); treeSet.add(20); //遍历:for-each for (Integer integer : treeSet) { System.out.println(integer); } System.out.println("--------------------"); //遍历2:使用迭代器 Iterator<Integer> iter = treeSet.iterator(); while(iter.hasNext()){ Integer i = iter.next(); System.out.println(i); } } }
根据内部Coparable接口定义的方法比较：
重写compareTo
public class Student implements Comparable<Student>{ private String name; private int age; public Student(){ } public Student(String name,int age){ this.name=name; this.age=age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } /** * 定义比较规则: * 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数 */ @Override public int compareTo(Student o) { // if(age>o.age){ // return 1; // }else if(age==o.age){ // return 0; // }else{ // return -1; // } return age-o.age; } }
import java.util.TreeSet; /** * TreeSet:使用元素的自然顺序对元素进行排序， * 或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 * TreeSet():构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。插入该 set 的所有元素都必须实现 Comparable接口 * */ public class TestTreeSet { public static void main(String[] args) { TreeSet<Student> treeSet = new TreeSet<Student>(); Student stu1 = new Student("zhangsan",20); Student stu2 = new Student("zhangsan2",18); Student stu3 = new Student("zhangsan3",25); treeSet.add(stu1); treeSet.add(stu2); treeSet.add(stu3); for (Student student : treeSet) { System.out.println(student.getName()+"---"+student.getAge()); } } }
实现Comparator接口，定义比较器比较
import java.util.Comparator; public class TeacherComparator implements Comparator<Teacher> { /** * 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。 */ @Override public int compare(Teacher arg0, Teacher arg1) { return -(arg0.getWorkOfYear()-arg1.getWorkOfYear()); } }
public class Teacher { private String name; private int workOfYear;//工作年限 public Teacher(String name, int workOfYear) { this.name = name; this.workOfYear = workOfYear; } public Teacher() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getWorkOfYear() { return workOfYear; } public void setWorkOfYear(int workOfYear) { this.workOfYear = workOfYear; } }
import java.util.TreeSet; /** * TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序 */ public class TestTreeSet2 { public static void main(String[] args) { TreeSet<Teacher> treeSet = new TreeSet<Teacher>(new TeacherComparator()); Teacher t1 = new Teacher("aa", 5); Teacher t2 = new Teacher("bb", 10); Teacher t3 = new Teacher("cc", 8); treeSet.add(t1); treeSet.add(t2); treeSet.add(t3); for (Teacher teacher : treeSet) { System.out.println(teacher.getName()+"---"+teacher.getWorkOfYear()); } } }
