List集合存储数据的结构:数据存储的常用结构有:堆栈、队列、数组、链表
特点:
1.堆栈:先进后出(即,存进去的元素,要在后面的元素依次取出后,才能取出该元素) 例如:子弹压弹夹;栈的入口/出口都在栈的顶端位置;弹栈:就是取元素(即把栈的顶端位置取出,栈中已有的元素向栈的顶方向移动)
2.队列:先进先出(即,存进去的元素,要在后面的元素依次取出后,才能取出该元素)例如:安检,依次检查;队列的入口、出口各占一侧.
3.数组:查找元素快,增删慢。
* 数组:
* 查询快:数组是有首地址,我们通过首地址可以快速找到数组对象,通过数组的索引快速找到数组中的每一个元素;数组地址是连续的arr[0] arr[1]
* 增删慢:数组的长度是固定的,我们想要给数组添加一个元素或减少一个元素,必须新建一个新数组,把原数组的元素复制到新的数组中
* 在内存中,频繁的建数组,复制数组,销毁数组,效率低,速度慢
* 底层原理的实现
* public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
* T[] copy = ((Object)newType == (Object)Object[].class)
* ? (T[]) new Object[newLength]
* : (T[]) Array.newInstance(newType.getComponentType(), newLength);
* System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
* return copy;
* }
4.链表:多个节点之间,通过地址进行连接,查找慢,增删快
链表的每一个元素,称之为一个节点(由两个指针域和一个数据域组成)
单向链表:只有一条链子,元素是无序的,存储元素和取出的元素的顺序可能不一致;存储a,b,c 取出可能b,c,a
使用单向链表的集合:HashSet,HashMap
双向链表:有两条链子,上一个的元素会记住下一个元素的地址;下一个元素也会记住上一个元素的地址;是有序的,存和取都是一致的
使用双向链表的集合:LinkedHashSet,LinkedHashMap
public class LinkedListDemo {
public static void main(String[] args) {
show3();
}
/*
* E removeFirst() 移除并返回此列表的第一个元素。
* E pop() 移除并返回此列表的第一个元素。 此方法等效于 removeFirst()。
* E removeLast() 移除并返回此列表的最后一个元素。
*/
private static void show3() {
LinkedList<String> linked = new LinkedList<String>();
//往集合的末尾追加元素
linked.add("aaa");
linked.add("bbb");
linked.add("ccc");
linked.add("dddd");
System.out.println(linked);
String removeFirst = linked.removeFirst();
System.out.println("返回移除元素:" + removeFirst);
System.out.println(linked);
String removeLast = linked.removeLast();
System.out.println("返回移除元素:" + removeLast);
System.out.println(linked);
}
/*
* E getFirst() 返回此列表的第一个元素。
* E getLast() 返回此列表的最后一个元素。
* boolean isEmpty() 如果列表不包含元素,则返回 true。
*/
private static void show2() {
//创建LinkedList对象
LinkedList<String> linked = new LinkedList<String>();
//往集合的末尾追加元素
linked.add("aaa");
linked.add("bbb");
linked.add("ccc");
linked.add("dddd");
//linked.clear();
if(!linked.isEmpty()){
String first = linked.getFirst();
System.out.println("first:" + first);
String last = linked.getLast();
System.out.println("last:" + last);
}
}
/*
* void addFirst(E e) 将指定元素插入此列表的开头。
* void push(E e) 将该元素插入此列表的开头。 此方法等效于 addFirst(E)。
* void addLast(E e) 将指定元素添加到此列表的结尾。相当于 add(E e)
*/
private static void show1() {
LinkedList<String> linkedList01 = new LinkedList<String>();
linkedList01.add("aaa");
linkedList01.add("bbb");
linkedList01.add("ccc");
System.out.println(linkedList01);
//void addFirst(E e) 将指定元素插入此列表的开头。
linkedList01.addFirst("ddd");
linkedList01.push("eee");//void push(E e) 将该元素插入此列表的开头。 此方法等效于 addFirst(E)。
System.out.println(linkedList01);
System.out.println("--------------------");
LinkedList<String> linkedList02 = new LinkedList<String>();
linkedList02.addLast("b");
linkedList02.addLast("c");
linkedList02.addLast("d");
linkedList02.addFirst("3");
linkedList02.addFirst("2");
linkedList02.addFirst("1");
System.out.println(linkedList02);
}
}
HashSet接口特点:1.底层是个哈希表(数组+链表); 查询快,又增删快
2.是一个无序的集合,储存元素和取出的可能不一致
此类为基本操作提供了稳定性能,这些基本操作包括 add、remove、contains 和 size,
假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小(元素的数量)和底层 HashMap
实例(桶的数量)的“容量”的和成比例。因此,如果迭代性能很重要,则不要将初始容量设置得太高(或将加载因子设置得太低)。public class HashSetDemo {
public static void main(String[] args) {
HashSet<String> hashSet = new HashSet<String>();
hashSet.add("张三");
hashSet.add("李四");
hashSet.add("王五");
hashSet.add("赵六");
//使用迭代器
Iterator<String> iterator = hashSet.iterator();
while (iterator.hasNext()) {
String string = (String) iterator.next();
System.out.println(string);
}
System.out.println("-----------");
for (String string : hashSet) {
System.out.println(string);
}
//赵六
//张三
//李四
//王五
}
}
java.util.LinkedHashSet集合 extends HashSet implments Set接口
特点:
1.不允许重复元素
2.底层是哈希表(数组+单向链表) + 单向链表组成,就是一个双向链表,新添加的链表就可以保证迭代顺序
public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHahSetM();
//保证ArrayList集合中元素不重复
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(1);
arrayList.add(1);
arrayList.add(1);
System.out.println(arrayList);//[1, 1, 1]
LinkedHashSet<Integer> hashSet = new LinkedHashSet<Integer>();
for (Integer integer : arrayList) {
hashSet.add(integer);
}
System.out.println(hashSet);//[1]
}
private static void LinkedHahSetM() {
//不允许重复,无序的
HashSet<String> hashSet = new HashSet<String>();
hashSet.add("杨贵妃");
hashSet.add("貂蝉");
hashSet.add("貂蝉");
hashSet.add("西施");
System.out.println(hashSet);//[西施, 杨贵妃, 貂蝉]
System.out.println("--------");
//不允许重复,有序的
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
linkedHashSet.add("杨贵妃");
linkedHashSet.add("貂蝉");
linkedHashSet.add("貂蝉");
linkedHashSet.add("西施");
System.out.println(linkedHashSet);//[杨贵妃, 貂蝉, 西施]
}
}
5.哈希值
哈希值:是一个十进制的整数,由操作系统随机给的
注意:如果给出的这个哈希值,没有其它使用,那么会重复给出
Object类中有一个方法叫 HashCode
intHashCode 返回该对象的哈希码值
public class HashCodeDemo {
public static void main(String[] args) {
personHashCode();
}
private static void personHashCode() {
Person person = new Person();
int hashCode = person.hashCode();
System.out.println(hashCode);//1321522194
/*
* xinfei.code.data.Demo_03.Person@5c3f1224 把十进制的整数转换为十六进制
* 反射 return getClass().getName() + @ + Interger.toHexString(HashCode());
*/
System.out.println(person);
}
}
HashSet储存数据不重复原理
/*
* HashSetc存储数据不重复的原理
*/
public class StringHashCodeDemo {
public static void main(String[] args) {
String str01 = new String("abc");
String str02 = new String("abc");
String str03 = "abc";
System.out.println(str01.hashCode());//96354
System.out.println(str02.hashCode());//96354
System.out.println(str03.hashCode());//96354
}
}
String类重写Object类的HashCode方法;String类底层是一个字符数组:用数组存储多个字符private final char value[];
private int hash; // Default to 0
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
//第一次遍历:h = 31*h+val[0] = 31*0+'a' = 97
//第二次遍历:h = 31*h+val[1] = 31*97+'b' = 3007 + 98 = 3105
/第三次遍历:h = 31*h+val[2] = 31*3105+'c' = 96255 + 99 = 96354