JavaSE集合之数据结构day10
第一章 数据结构
1.1常见的数据结构
1.1.1栈
- 栈：stack，又称堆栈，它是运输受限的的线性表，其限制是仅允许在标的同一端进行插入和删除操作，不允许在其他任何位置进行添加，查找，删除，等操作
- 先进后出
- 栈的入口，出口都是栈的顶端位置
- 栈的图像理解
1.1.2 队列
- 队列：queue，简称队，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。
- 先进先出
- 队列的入口，出口各占一侧
- 队列的图型理解
1.1.3 数组
- 数组：Array，是有序的元素序列，数组是在内存中开辟一段连续的空间，并在次空间存放元素。
- 查找速度快
- 增删元素慢
- 快慢的图形理解
1.1.4 链表
-
链表：linked list,由一系列结点node(链表中每一个元素称为结点)组成，结点可以动态生成，每一个结点包含两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
-
查找元素慢
-
增删元素快
-
快慢图形理解
1.1.5红黑树
-
二叉树：binary tree,是每个结点不超过2的有序树(tree)。
-
树的概念和理解
第二章 List集合
1. List接口介绍
- List接口的特点
- 它是一个元素存取有序的集合。
- 它是一个带索引的集合，通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)
- 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素
2.List接口1中常用方法
-
public void add(int index,E element): 将指定的元素，添加到该集合的指定位置上
-
public E remove(int index):移除列表中指定的位置元素，返回的是被移除的元素
-
public E set(int index, E element); 用指定的元素替换集合中指定位置的元素，返回值的更新前的元素
package collective.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
java.util.list 接口，Collection 接口
List接口的特点：
1.有序的集合，存储元素和取出元素的顺序是一致的（存储123 取出123）
2.有索引，包含了一些带索引的方法
3.允许存储重复的元素
注意：
操作索引的时候，防止索引越界异常
*/
public class Demo01List {
public static void main(String[] args) {
//创建一个List集合对象，多态
List<String> list =new ArrayList<>();
//使用add方法往集合中添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
//打印集合
System.out.println(list);//不是地址重写了toString
//public void add(int index,E element): 将指定的元素，添加到该集合的指定位置上
//在c,d之间添加呆呆哥
list.add(3,"呆呆哥");
System.out.println(list);
//public E remove(int index):移除列表中指定的位置元素，返回的是被移除的元素
String remove= list.remove(2);
System.out.println("被移除的元素是："+remove);
System.out.println(list);
//public E set(int index, E element); 用指定的元素替换集合中指定位置的元素，返回值的更新前的元素
String set =list.set(3,"呆大哥");
System.out.println("被替换的元素是："+set);
System.out.println(list);
//List集合遍历有三种方式
//使用普遍的for循环
for (int i = 0; i < list.size(); i++) {
//public E get(int index):返回集合中指定位置的元素
String s =list.get(i);
System.out.print(s+"\t");
}
System.out.println();
System.out.println("===========");
//使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()){
String s = it.next();
System.out.print(s+"\t");
}
System.out.println();
System.out.println("=========");
//使用增强for循环
for (String s : list) {
System.out.print(s+"\t");
}
System.out.println();
}
}
结果：
[a, b, c, d, a]
[a, b, c, 呆呆哥, d, a]
被移除的元素是：c
[a, b, 呆呆哥, d, a]
被替换的元素是：d
[a, b, 呆呆哥, 呆大哥, a]
a b 呆呆哥 呆大哥 a
===========
a b 呆呆哥 呆大哥 a
=========
a b 呆呆哥 呆大哥 a
第三章 List的子类
3.1 ArrayList集合
java.util.ArrayList 集合数据结构存储的结构是数据结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据，遍历数据，所以ArrayList是最常用的集合。
3.2 LinkedList集合
-
public void addFirst(E e) 将指定元素插入此列表的开头。
-
public void addLast(E e)将指定元素添加到此列表的结尾。
-
public void push(E e)将元素推入此列表所表示的堆栈。换句话说，将该元素插入此列表的开头。 此方法等效于 addFirst(E)。
-
public E getFirst()返回此列表的第一个元素。
-
public E getLast()返回此列表的最后一个元素。
-
public E removeFirst()移除并返回此列表的第一个元素。
-
public E removeLast()移除并返回此列表的最后一个元素。
-
public E pop()从此列表所表示的堆栈处弹出一个元素。换句话说，移除并返回此列表的第一个元素。此方法等效于 removeFirst()。
-
public boolean isEmpty(): 如果列表不包含元素，则返回true
package collective.List;
import java.util.LinkedList;
/*
java.util.LinkedList集合 implement list 接口
LinkedList集合的特点：
1.底层是一个链表结构：查询慢，增删快
2.里面包含了大量的操作首尾元素的方法
注意：使用了LinkedList集合的方法，不能使用多态
*/
public class Demo02List {
public static void main(String[] args) {
show01();
}
public static void show01(){
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);
//public void addFirst(E e) 将指定元素插入此列表的开头。
linked.addFirst("呆呆哥");
System.out.println(linked);
//public void addLast(E e)将指定元素添加到此列表的结尾。
linked.addLast("呆小妹");
System.out.println(linked);
//public void push(E e)将元素推入此列表所表示的堆栈。换句话说，
// 将该元素插入此列表的开头。 此方法等效于 addFirst(E)。
linked.push("呆大哥");
System.out.println(linked);
//public E getFirst()返回此列表的第一个元素。
//public E getLast()返回此列表的最后一个元素
String first = linked.getFirst();
System.out.println("第一个数是:"+first);
String last = linked.getLast();
System.out.println("最后一个数是:"+last);
// public E removeFirst()移除并返回此列表的第一个元素。
//public E removeLast()移除并返回此列表的最后一个元素。
//public E pop()从此列表所表示的堆栈处弹出一个元素。换句话说
//移除并返回此列表的第一个元素。此方法等效于 removeFirst()。
String refirst = linked.removeFirst();
System.out.println("移除第一个是："+refirst);
String relast = linked.removeLast();
System.out.println("移除最后一个是："+relast);
String pop = linked.pop();
System.out.println("移除最后一个是："+pop);
//public boolean isEmpty(): 如果列表不包含元素，则返回true
System.out.println("列表中不存在元素："+linked.isEmpty());
System.out.println(linked);
}
}
结果：
[a, b, c]
[呆呆哥, a, b, c]
[呆呆哥, a, b, c, 呆小妹]
[呆大哥, 呆呆哥, a, b, c, 呆小妹]
第一个数是:呆大哥
最后一个数是:呆小妹
移除第一个是：呆大哥
移除最后一个是：呆小妹
移除最后一个是：呆呆哥
列表中不存在元素：false
[a, b, c]
第四章 Set接口
java.uitl.Set接口和java.util.List接口一样，同样继承Collection接口中的方法基本一致。
java.util.Set接口 extends Collection接口
-
Set接口的特点：
-
不允许存储重复的元素
-
没有索引，没有带索引的方法，也不能使用普通的for循环遍历
-
4.1 HashSet集合介绍
java.util.HashSet集合 implements Set接口
-
HashSet特点：
-
不允许存储重复的元素
-
没有索引，没有带索引的方法，也不能使用普通的for循环遍历
-
是一个无序的集合，存储元素和取出元素的顺序有可能不一致
-
底层是一个哈希表结构(查询的速度非常快）
-
package collective.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
java.util.Set接口 extends Collection接口
Set接口的特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set接口
HashSet特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构(查询的速度非常快）
*/
public class Demo01Set {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
//添加元素add
set.add(1);
set.add(2);
set.add(3);
set.add(1);
set.add(5);
//使用迭代器遍历
Iterator<Integer> it =set.iterator();
while (it.hasNext()){
Integer integer = it.next();
System.out.print(integer+"\t");
}
System.out.println();
System.out.println("=============");
//增强for循环
for (Integer integer : set) {
System.out.print(integer+"\t");
}
}
}
结果：
1 2 3 5
=============
1 2 3 5
4.2 哈希值
-
哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址不是数据实际的物理地址）在Object类有一个方法，可以获取对象的哈希码值
-
hashCode方法的源码：
public native int hashCode();
native:代表该方法调用的是本地操作系统方法
4.3HashSet集合存储的结构（哈希表）
-
什么是哈希表？
- 在JDK1.8之前，哈希表底层采用数组+链表实现
- 在JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表超过阙值（8）时，将链表转换成红黑树，减少时间
-
图形理解
4.3 HashSet存储自定义类型元素
- 给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合的对象唯一
- HashSet存储不重复图解
package collective.Set;
import java.util.HashSet;
public class Demo02HashSetString {
public static void main(String[] args) {
//创建HashSet集合对象
HashSet<String> set = new HashSet<>();
String s1 =new String("abc");
String s2 =new String("abc");
set.add(s1);
set.add(s2);
set.add("重地");
set.add("通话");
System.out.println(set);
}
}
结果：
[重地, 通话, abc]
- 自定义元素
package collective.Set;
import java.util.Objects;
public class Person {
private String name;
private int age ;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", 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 boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return getAge() == person.getAge() &&
Objects.equals(getName(), person.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getAge());
}
}
package collective.Set;
import java.util.HashSet;
/*
HashSet存储自定义类型元素
set集合抱错元素唯一
存储元素（String Integer,.....)必须重写hasCode方法和equals方法
要求：
同名同年纪的人只能存储一次。
*/
public class Demo03HashSetPerson {
public static void main(String[] args) {
//创建HashSet集合存储Person
HashSet<Person> set =new HashSet<>();
Person p1 = new Person("呆呆哥",22);
Person p2 = new Person("呆呆哥",22);
Person p3 = new Person("呆呆妹",21);
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println(set);
}
}
结果：
[Person{name='呆呆哥', age=22}, Person{name='呆呆妹', age=21}]
4.4 LinkedHashSet集合
- 它是链表和哈希表组合的一个数据存储结构（有序）
package collective.Set;
import java.util.HashSet;
import java.util.LinkedHashSet;
/*
java.util.LinkedHashSet 集合extends HashSet
LinkedHashSet集合特点：
底层是一个哈希表（数组+链表/红黑树）+链表：
多了一条列表（记录元素的存储顺序），保证元素有序
*/
public class Demo04LinkedHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("呆大哥");
set.add("呆小妹");
set.add("abc");
set.add("abc");
set.add("呆呆哥");
System.out.println(set);//无序，不允许重复
System.out.println("=================");
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("呆大哥");
linked.add("呆小妹");
linked.add("abc");
linked.add("abc");
linked.add("呆呆哥");
System.out.println(linked);//有序不重复
}
}
结果：
[呆大哥, abc, 呆呆哥, 呆小妹]
=================
[呆大哥, 呆小妹, abc, 呆呆哥]
总结
今天很认真的在学，收获到了也很多表现不错，给自己一个摸摸哒。明天的话就可以把集合看完，然后就可以进攻I/O流了。今天还写了一个斗地主的案例，虽然在程序里跑出来，但是感觉还是不错的。这个是集合类的结合，下来可以以写斗地主为例子来联系和巩固集合类的知识。今天还发现了一个最傻瓜的问题就是我他喵的把Demo写成了Doem，你他喵的是没入门蛮。这么简单的单词都写错了，这个以后经常用到。以后写错了别人还以为你是一个菜鸡，所以说细节是很重要滴。加油哦！！！
2020/7/21 23：04
二号楼 314
扫一扫
564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
