2、使用ListIterator
//顺序遍历
ListIterator lit = list.listIterator();
while(lit.hasNext()) {
System.out.println(lit.next());
}
//逆序遍历
while (lit.hasPrevious()) {
System.out.println(lit.previous());
}ListIterator常用方法
boolean hasNext() 返回 true如果列表迭代器具有更多的元素时，正向遍历列表。
boolean hasPrevious() 返回 true如果列表迭代器具有更多的元素时，逆向遍历列表。
E next() 返回列表中的下一个元素，并推进光标位置。
E previous() 返回列表中的前一个元素，并向后移动光标位置。
void remove() 从列表中删除最后一个元素是由 next()或 previous()返回（可选操作）。
6.List实现类
三种实现类
ArrayList【重点】
数组结构实现，查询快、增删慢；
运行效率快、线程不安全。
LinkedList
Vector（很少使用）
重写equals()方法
当要删除List中的指定对象时，需要比较两个对象是否相同，如果要实现不根据同一引用删除属性相同的对象，此时需要在该对象类中重写equals方法，如下为经典的重写方法，记下来。
@Override
public boolean equals(Object obj) {
//是否为同一对象
if (this == obj) {
return true;
}
//是否为空
if (this == null) {
return false;
}
//是否为同类对象
if (obj instanceof Student) {
Student s = (Student) obj;
//比较属性是否相等
if(this.name = s.name && this.age == s.age){
return true;
}
}
return false;
}ArraysList源码解析
重要参数：
add()方法源码解析
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
private void add(E e, Object[] elementData, int s) {
//数组存放满了，扩容
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
//扩容
private Object[] grow() {
return grow(size + 1);
}
//将旧数组扩容
private Object[] grow(int minCapacity) {
return elementData = Arrays.copyOf(elementData,
newCapacity(minCapacity));
}
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity <= 0) {
//数组为空
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
return Math.max(DEFAULT_CAPACITY, minCapacity);
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE)
? Integer.MAX_VALUE
: MAX_ARRAY_SIZE;
}LinkedList源码解析
相关参数：
int size：集合的大小
Node first：链表头节点
Node last：链表尾节点
add方法源码
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}7.泛型
泛型概念
泛型类
1.定义泛型类及泛型的用途
/**
* 泛型类
* 语法：类名
* T 是类型占位符，表示一种引用类型，如果编写多个则使用逗号隔开
* @param
*/
public class MyGeneric {
//使用泛型
//1.创建变量
T t;
//2.泛型作为方法的参数
public void show(T t) {
System.out.println(t);
}
//3.泛型作为方法的返回值
public T getT() {
return t;
}
}
2.使用泛型
注意：
（1）泛型只能使用引用类型；
（2）不同泛型类型对象之间不能相互赋值。
public class TestGeneric {
public static void main(String[] args) {
MyGeneric myGeneric = new MyGeneric<>();
myGeneric.t = "苹果";
myGeneric.show("吃苹果");
MyGeneric myGeneric1 = new MyGeneric<>();
myGeneric.t = "100";
myGeneric.show("打100分");
}
}泛型接口
（1）定义泛型
/**
* 泛型接口
* 语法：接口名
* 注意：不能使用泛型创建静态常量
*/
public interface MyInterface {
String name = "apple";
T server(T t);
}
（2）使用泛型
//1.写实现类时指定类型
public class MyInterfaceImpl implements MyInterface{
@Override
public String server(String s) {
return s;
}
}
//2.创建对象时再指定类型
public class MyInterfaceImpl1 implements MyInterface {
@Override
public T server(T t) {
return t;
}
}
public class TestGeneric {
public static void main(String[] args) {
MyInterfaceImpl1 myInterfaceImpl1 = new MyInterfaceImpl1<>();
System.out.println(myInterfaceImpl1.server("apple1"));
}
}
泛型方法
（1）定义
/**
* 泛型方法
* 语法： 返回值类型
*/
public class GenericMethod {
//泛型方法, 泛型T可以作为方法的参数或返回值
public void show(T t) {
System.out.println(t);
}
}
（2）使用
在使用时传入具体类型的值。
public class TestGeneric {
public static void main(String[] args) {
GenericMethod genericMethod = new GenericMethod();
genericMethod.show("apple");
genericMethod.show(200);
genericMethod.show(3.14);
}
}泛型集合
概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点：
编译时即可检查，而非运行时抛出异常；
访问时，不必类型转换（拆箱）；
不同泛型之间引用不能相互赋值，泛型不存在多态。
public class TestGeneric {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("apple");
arrayList.add("banana");
arrayList.add(100);
arrayList.add(3.14);
for (Object object : arrayList) {
System.out.println(object);
}
//使用泛型限定传入的元素类型
ArrayList arrayList1 = new ArrayList<>();
arrayList1.add("apple");
arrayList1.add(100); //添加其它类型时会报错
}
}8.Set子接口
特点：无序、无下标、元素不可重复；
方法：全部继承自Collection中的方法。
1.Set实现类
2.遍历
使用foreach和Iterator。
public class Demo7 {
public static void main(String[] args) {
Set set = new HashSet<>();
set.add("Jack"); set.add("Lucy"); set.add("Micheal");
//1.foreach
for(String string : set)
System.out.println(string);
//2.Iterator
Iterator it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}3.HashSet
存储结构：哈希表（数组+链表+红黑树）；
存储过程：
重写hashcode()与equals()方法
@Override
public int hashCode() {
return Objects.hash(age, name);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
//getClass()返回对象的hashcode
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}4.TreeSet
存储结构：红黑树
（1）存储元素为对象时必须实现Comparable接口
并重写其中的compareTo方法，否则元素之间无法比较大小，不能排序，会报类型转换错误。
compareTo()返回为0，表示元素重复。
foreach与迭代器方式
package collectionTest;
import java.util.Objects;
public class Person implements Comparable{
//TODO
@Override
public int compareTo(Object o1) {
Person o = (Person)o1;
int n1 = this.getName().compareTo(o.getName());
int n2 = this.getAge() - o.getAge();
return n1 == 0 ? n2 : n1;
}
}（2）Comparator
实现定制的比较器，并在创建TreeSet时传入该比较器指定比较规则，如此存储的元素对象便不用实现Comparable接口。
public class Demo3 {
public static void main(String[] args) {
//使用匿名内部类
TreeSet hashSet = new TreeSet<>(new Comparator() {
@Override
public int compare(Person o1, Person o2) {
int n2 = o1.getName().compareTo(o2.getName());
int n1 = o1.getAge() - o2.getAge();
return n1 == 0 ? n2 : n1;
}
});
}
}9.Map集合
Map父接口
特点：存储键值对，无序、无下标，键不可重复，值可重复。
方法：
遍历
（1）使用keySet()
（2）使用entrySet()
public class Demo5 {
public static void main(String[] args) {
HashMap hashMap = new HashMap<>();
hashMap.put(1, "Jack");
hashMap.put(2, "Lucy");
hashMap.put(3, "asdfaJack");
hashMap.put(4, "DLucy");
//1.keySet()
// Set keySet = hashMap.keySet();
for(Integer key : hashMap.keySet()) {
System.out.println(key + " : " + hashMap.get(key));
}
//2.entrySet()
// Set> entries = hashMap.entrySet();
for(Map.Entry entry : hashMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}Map集合的实现类
HashMap：线程不安全，运行效率快；允许使用null作为key或value;
Hashtable：线程安全，运行效率慢，不允许null作为key或value。
TreeMap：实现了SortedMap接口（是Map的子接口），可以对key自动排序。
HashMap源码解析
相关参数
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashmap初始容量大小
static final int MAXIMUM_CAPACITY = 1 << 30; //hashmap数组最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; //默认装载因子
static final int TREEIFY_THRESHOLD = 8; //jdk1.8 当链表长度大于8时，调整成红黑树
static final int UNTREEIFY_THRESHOLD = 6; //链表长度小于6，调整成链表
static final int MIN_TREEIFY_CAPACITY = 64; //jdk1.8 当链表长度大于8且集合元素个数大于等于64时，调整成红黑树。
transient Node[] table; //哈希表中的数组
transient size; //元素个数
构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//刚创建的hashmap没有添加元素，table=null，size=0
HashMap hashMap = new HashMap<>();put() 方法解析，待深入了解。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}TreeMap
TreeMap与TreeSet一样，底层都是由红黑树实现，是有序的，因此元素之间必须是可比较的，可以通过让元素继承Comparable或者在调用TreeMap的构造方法时传入自制比较器实现。
遍历方式
（1）使用keySet()
（2）使用entrySet()
public class Demo6 {
public static void main(String[] args) {
TreeMap treeMap = new TreeMap<>();
Student s1 = new Student(11, "Jack");
Student s2 = new Student(17, "adfJack");
Student s3 = new Student(14, "dafJack");
Student s4 = new Student(12, "fJdack");
treeMap.put(s1, "nihao");
treeMap.put(s2, "nihao");
treeMap.put(s3, "nihao");
treeMap.put(s4, "nihao");
for(Student key : treeMap.keySet()) {
System.out.println(key + " : " + treeMap.get(key));
}
for(Map.Entry entry : treeMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}
class Student implements Comparable{
private int age;
private String name;
//TODO
}10.Collections工具类
概念：集合工具类，定义了出了存取以外的集合常用方法。
方法
void sort(List list) 指定列表为升序排序，根据其元素的 natural ordering。
void sort(List list, Comparator c) 根据指定的比较器指定的顺序对指定的列表进行排序。
static void reverse(List list) 反转指定列表中元素的顺序。
static void shuffle(List list) 随机置换指定列表使用随机默认源。
static void swap(List list, int i, int j) 在指定的列表中的指定位置上交换元素。
static void copy(List dest, List src) 将所有的元素从一个列表复制到另一个列表中。
copy函数，必须保证dst的长度与src一致。
public class Demo7 {
public static void main(String[] args) {
List src = new ArrayList<>();
src.add(1);src.add(2);src.add(100);src.add(89);
List dst = new ArrayList<>();
//让dst的长度与src一致
for(int i=0; i11.Arrays工具类
方法
static List asList(T... a) 返回由指定数组支持的一个固定大小的列表。
List转数组
public class Demo7 {
public static void main(String[] args) {
List src = new ArrayList<>();
src.add(1);src.add(2);src.add(100);src.add(89);
//传入数组类型作为参数
Integer[] integers = src.toArray(new Integer[0]);
System.out.println(Arrays.toString(integers));
}
}数组转集合
public class Demo7 {
public static void main(String[] args) {
Integer[] integers = new Integer[] {1, 2, 3, 4, 5};
List list = Arrays.asList(integers);
System.out.println(list);
}
}感谢你能够认真阅读完这篇文章，希望小编分享的“Java集合是什么”这篇文章对大家有帮助，同时也希望大家多多支持创新互联，关注创新互联行业资讯频道，更多相关知识等着你来学习!
新闻标题：Java集合是什么
当前URL：http://cdkjz.cn/article/gopoic.html
