一、List接口 二、Set接口 三、判断集合惟一性原理
01List接口的特色
A:List接口的特色:
a:它是一个元素存取有序的集合。java
例如，存元素的顺序是十一、2二、33。那么集合中，元素的存储就是按照十一、2二、33的顺序完成的）。
b:它是一个带有索引的集合，经过索引就能够精确的操做集合中的元素（与数组的索引是一个道理）。
面试
c:集合中能够有重复的元素，经过元素的equals方法，来比较是否为重复的元素。 d:List接口的经常使用子类有：
ArrayList集合
LinkedList集合数组
02List接口的特有方法
A:List接口的特有方法(带索引的方法)
a:增长元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e) 向集合指定索引处，添加指定的元素，原有元素依次后移安全
/*
* add(int index, E)
* 将元素插入到列表的指定索引上
* 带有索引的操做,防止越界问题
* java.lang.IndexOutOfBoundsException
* ArrayIndexOutOfBoundsException
* StringIndexOutOfBoundsException
*/
public static void function(){
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
list.add(1, "itcast");
System.out.println(list);
}
b:删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素数据结构
/*
* E remove(int index)
* 移除指定索引上的元素
* 返回被删除以前的元素
*/
public static void function_1(){
List<Double> list = new ArrayList<Double>();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d = list.remove(0);
System.out.println(d);
System.out.println(list);
}
c:替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素并发
/*
* E set(int index, E)
* 修改指定索引上的元素
* 返回被修改以前的元素
*/
public static void function_2(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i = list.set(0, 5);
System.out.println(i);
System.out.println(list);
}
d:查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素性能
03迭代器的并发修改异常
A:迭代器的并发修改异常
/*
* 迭代器的并发修改异常 java.util.ConcurrentModificationException
* 就是在遍历的过程当中,使用了集合方法修改了集合的长度,不容许的
*/
public class ListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//对集合使用迭代器进行获取,获取时候判断集合中是否存在 "abc3"对象
//若是有,添加一个元素 "ABC3"
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
//对获取出的元素s,进行判断,是否是有"abc3"
if(s.equals("abc3")){
list.add("ABC3");
}
System.out.println(s);
}
}
}
运行上述代码发生了错误 java.util.ConcurrentModificationException这是什么缘由呢？
在迭代过程当中，使用了集合的方法对元素进行操做。
致使迭代器并不知道集合中的变化，容易引起数据的不肯定性。
并发修改异常解决办法：
在迭代时，不要使用集合的方法操做元素。
或者经过ListIterator迭代器操做元素是能够的，ListIterator的出现，解决了使用Iterator迭代过程当中可能会发生的错误状况。
04数据的存储结构
A:数据的存储结构
a:栈结构:后进先出/先进后出(手枪弹夹) FILO (first in last out)
b:队列结构:先进先出/后进后出(银行排队) FIFO(first in first out)
c:数组结构:
查询快:经过索引快速找到元素
增删慢:每次增删都须要开辟新的数组,将老数组中的元素拷贝到新数组中
开辟新数组耗费资源
d:链表结构
查询慢:每次都须要从链头或者链尾找起
增删快:只须要修改元素记录的下个元素的地址值便可不须要移动大量元素
=======================第二节课开始=============================================this
05ArrayList集合的自身特色
A:ArrayList集合的自身特色线程
底层采用的是数组结构
ArrayList al=new ArrayList();//建立了一个长度为0的Object类型数组
al.add("abc");//底层会建立一个长度为10的Object数组 Object[] obj=new Object[10]
//obj[0]="abc"
//若是添加的元素的超过10个,底层会开辟一个1.5*10的长度的新数组
//把原数组中的元素拷贝到新数组,再把最后一个元素添加到新数组中
原数组:code
a b c d e f g h k l
添加m:
a b c d e f g h k l m null null null null
06LinkedList集合的自身特色
A:LinkedList集合的自身特色
底层采用链表结构,每次查询都要从链头或链尾找起,查询相对数组较慢 可是删除直接修改元素记录的地址值便可,不要大量移动元素 LinkedList的索引决定是从链头开始找仍是从链尾开始找 若是该元素小于元素长度一半,从链头开始找起,若是大于元素长度的一半,则从链尾找起
07LinkedList特有方法
*A:LinkedList特有方法:获取,添加,删除
/*
* LinkedList 链表集合的特有功能
* 自身特色: 链表底层实现,查询慢,增删快
*
* 子类的特有功能,不能多态调用
*/
public class LinkedListDemo {
public static void main(String[] args) {
function_3();
}
/*
* E removeFirst() 移除并返回链表的开头
* E removeLast() 移除并返回链表的结尾
*/
public static void function_3(){
LinkedList<String> link = new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.add("4");
String first = link.removeFirst();
String last = link.removeLast();
System.out.println(first);
System.out.println(last);
System.out.println(link);
}
/*
* E getFirst() 获取链表的开头
* E getLast() 获取链表的结尾
*/
public static void function_2(){
LinkedList<String> link = new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.add("4");
if(!link.isEmpty()){
String first = link.getFirst();
String last = link.getLast();
System.out.println(first);
System.out.println(last);
}
}
public static void function_1(){
LinkedList<String> link = new LinkedList<String>();
link.addLast("a");
link.addLast("b");
link.addLast("c");
link.addLast("d");
link.addFirst("1");
link.addFirst("2");
link.addFirst("3");
System.out.println(link);
}
/*
* addFirst(E) 添加到链表的开头
* addLast(E) 添加到链表的结尾
*/
public static void function(){
LinkedList<String> link = new LinkedList<String>();
link.addLast("heima");
link.add("abc");
link.add("bcd");
link.addFirst("itcast");
System.out.println(link);
}
}
08Vector类的特色
*A:Vector类的特色
Vector集合数据存储的结构是数组结构，为JDK中最先提供的集合,它是线程同步的 Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器。 此接口Enumeration的功能与 Iterator 接口的功能是相似的。 Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。
=======================第三节课开始=============================================
09Set接口的特色
A:Set接口的特色
a:它是个不包含重复元素的集合。 b:Set集合取出元素的方式能够采用：迭代器、加强for。 c:Set集合有多个子类，这里咱们介绍其中的HashSet、LinkedHashSet这两个集合。
10Set集合存储和迭代
A:Set集合存储和迭代
/*
* Set接口,特色不重复元素,没索引
*
* Set接口的实现类,HashSet (哈希表)
* 特色: 无序集合,存储和取出的顺序不一样,没有索引,不存储重复元素
* 代码的编写上,和ArrayList彻底一致
*/
public class HashSetDemo {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("cn");
set.add("heima");
set.add("java");
set.add("java");
set.add("itcast");
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("==============");
for(String s : set){
System.out.println(s);
}
}
}
11哈希表的数据结构
A:哈希表的数据结构:(参见图解)
加载因子:表中填入的记录数/哈希表的长度
例如:
加载因子是0.75 表明:
数组中的16个位置,其中存入16*0.75=12个元素
若是在存入第十三个(>12)元素,致使存储链子过长,会下降哈希表的性能,那么此时会扩充哈希表(在哈希),底层会开辟一个长度为原长度2倍的数组,把老元素拷贝到新数组中,再把新元素添加数组中
当存入元素数量>哈希表长度*加载因子,就要扩容,所以加载因子决定扩容时机
12字符串对象的哈希值
A:字符串对象的哈希值
/*
* 对象的哈希值,普通的十进制整数
* 父类Object,方法 public int hashCode() 计算结果int整数
*/
public class HashDemo {
public static void main(String[] args) {
Person p = new Person();
int i = p.hashCode();
System.out.println(i);
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
/*System.out.println("重地".hashCode());
System.out.println("通话".hashCode());*/
}
}
//String类重写hashCode()方法
//字符串都会存储在底层的value数组中{'a','b','c'}
public int hashCode() {
int h = hash;//hash初值为0
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;
}
13哈希表的存储过程
A:哈希表的存储过程
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add(new String("abc"));
set.add(new String("abc"));
set.add(new String("bbc"));
set.add(new String("bbc"));
System.out.println(set);
}
存取原理:
每存入一个新的元素都要走如下三步: 1.首先调用本类的hashCode()方法算出哈希值 2.在容器中找是否与新元素哈希值相同的老元素, 若是没有直接存入 若是有转到第三步 3.新元素会与该索引位置下的老元素利用equals方法一一对比 一旦新元素.equals(老元素)返回true,中止对比,说明重复,再也不存入 若是与该索引位置下的老元素都经过equals方法对比返回false,说明没有重复,存入
=======================第四节课开始=============================================
14哈希表的存储自定义对象
A:哈希表的存储自定义对象
/*
* HashSet集合的自身特色:
* 底层数据结构,哈希表
* 存储,取出都比较快
* 线程不安全,运行速度快
*/
public class HashSetDemo1 {
public static void main(String[] args) {
//将Person对象中的姓名,年龄,相同数据,看做同一个对象
//判断对象是否重复,依赖对象本身的方法 hashCode,equals
HashSet<Person> setPerson = new HashSet<Person>();
setPerson.add(new Person("a",11));
setPerson.add(new Person("b",10));
setPerson.add(new Person("b",10));
setPerson.add(new Person("c",25));
setPerson.add(new Person("d",19));
setPerson.add(new Person("e",17));//每一个对象的地址值都不一样,调用Obejct类的hashCode方法返回不一样哈希值,直接存入
System.out.println(setPerson);
}
}
public class Person {
private String name;
private int 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;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
public String toString(){
return name+".."+age;
}
}
15自定义对象重写hashCode和equals
A:自定义对象重写hashCode和equals
/*
* HashSet集合的自身特色:
* 底层数据结构,哈希表
* 存储,取出都比较快
* 线程不安全,运行速度快
*/
public class HashSetDemo1 {
public static void main(String[] args) {
//将Person对象中的姓名,年龄,相同数据,看做同一个对象
//判断对象是否重复,依赖对象本身的方法 hashCode,equals
HashSet<Person> setPerson = new HashSet<Person>();
setPerson.add(new Person("a",11));
setPerson.add(new Person("b",10));
setPerson.add(new Person("b",10));
setPerson.add(new Person("c",25));
setPerson.add(new Person("d",19));
setPerson.add(new Person("e",17));
System.out.println(setPerson);
}
}
public class Person {
private String name;
private int age;
/*
* 没有作重写父类,每次运行结果都是不一样整数
* 若是子类重写父类的方法,哈希值,自定义的
* 存储到HashSet集合的依据
*
* 尽量让不一样的属性值产生不一样的哈希值,这样就不用再调用equals方法去比较属性
*
*/
public int hashCode(){
return name.hashCode()+age*55;
}
//方法equals重写父类,保证和父类相同
//public boolean equals(Object obj){}
public boolean equals(Object obj){
if(this == obj)
return true;
if(obj == null)
return false;
if(obj instanceof Person){
Person p = (Person)obj;
return name.equals(p.name) && age==p.age;
}
return false;
}
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;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
public String toString(){
return name+".."+age;
}
}
16LinkedHashSet集合
A:LinkedHashSet集合
/*
* LinkedHashSet 基于链表的哈希表实现
* 继承自HashSet
*
* LinkedHashSet 自身特性,具备顺序,存储和取出的顺序相同的
* 线程不安全的集合,运行速度块
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHashSet<Integer> link = new LinkedHashSet<Integer>();
link.add(123);
link.add(44);
link.add(33);
link.add(33);
link.add(66);
link.add(11);
System.out.println(link);
}
}
17ArrayList,HashSet判断对象是否重复的缘由
A:ArrayList,HashSet判断对象是否重复的缘由
a:ArrayList的contains方法原理:底层依赖于equals方法
ArrayList的contains方法会使用调用方法时，
传入的元素的equals方法依次与集合中的旧元素所比较，
从而根据返回的布尔值判断是否有重复元素。
此时，当ArrayList存放自定义类型时，因为自定义类型在未重写equals方法前，
判断是否重复的依据是地址值，因此若是想根据内容判断是否为重复元素，须要重写元素的equals方法。
b:HashSet的add()方法和contains方法()底层都依赖 hashCode()方法与equals方法()
Set集合不能存放重复元素，其添加方法在添加时会判断是否有重复元素，有重复不添加，没重复则添加。
HashSet集合因为是无序的，其判断惟一的依据是元素类型的hashCode与equals方法的返回结果。规则以下：
先判断新元素与集合内已经有的旧元素的HashCode值
若是不一样，说明是不一样元素，添加到集合。
若是相同，再判断equals比较结果。返回true则相同元素；返回false则不一样元素，添加到集合。
因此，使用HashSet存储自定义类型，若是没有重写该类的hashCode与equals方法，则判断重复时，使用的是地址值，若是想经过内容比较元素是否相同，须要重写该元素类的hashcode与equals方法。
18hashCode和equals方法的面试题
A:hashCode和equals的面试题
/*
两个对象 Person p1 p2
问题: 若是两个对象的哈希值相同 p1.hashCode()==p2.hashCode()
两个对象的equals必定返回true吗 p1.equals(p2) 必定是true吗
正确答案:不必定
若是两个对象的equals方法返回true,p1.equals(p2)==true
两个对象的哈希值必定相同吗
正确答案: 必定
*/
在 Java 应用程序执行期间，
1.若是根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每一个对象调用 hashCode 方法都必须生成相同的整数结果。
2.若是根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求必定生成不一样的整数结果。
两个对象不一样(对象属性值不一样) equals返回false=====>两个对象调用hashCode()方法哈希值相同 两个对象调用hashCode()方法哈希值不一样=====>equals返回true
两个对象不一样(对象属性值不一样) equals返回false=====>两个对象调用hashCode()方法哈希值不一样 两个对象调用hashCode()方法哈希值相同=====>equals返回true
因此说两个对象哈希值不管相同仍是不一样,equals均可能返回true
并发修改异常(重点)
描述的是：集合和迭代器同时持有同一个对象，当集合在添加，和删除集合元素时（修改呢），迭代器并不知道，因此会发生并发修改异常
注意：加强for也会产生并发修改异常
如何解决： 第一： 使用普通for循环
第二(重点):使用listIterator -->是List 特有的，其余集合不能使用
代码：
经常使用方法：
a、 E set(int index, E) 修改指定索引上的元素，返回被修改以前的元素 b、 E remove(int index) 移除指定索引上的元素，返回被删除以前的元素 c、 add(int index, E)将元素插入到列表的指定索引上，其余元素顺移 d、remove(int index) 删除并返回元素
数据类型：
栈 ： 手枪的弹夹 : 手枪的压栈 ---> 喝酒 --->先进后出，后进先出
队列 : 超市的购物，先排队，先处理 ---> 喝酒 --->先进去，先出来，后进去，后出来
数组 : 查找快:由于底层有索引，而且是连续
增删慢: 数组的长度的是固定的，当咱们在进行增删时，会建立一个新的数组，而且将老数组中的值拷贝到新数组中
链表： 查找慢（底层是链表，两两相连，依次往下找，直到找到为止） --->linkedList 采用二分法查找
增删快 :缘由在于他仅仅只须要改变相邻元素的地址值
arrayList的特色
底层是可变数组查找快:由于底层有索引，而且是连续
linkedList 的特色：
查找慢（底层是链表，两两相连，依次往下找，直到找到为止） Vector ： 已经被淘汰，是线程安全的，效率低，其余和arrayList 一致
需求：
我想本身实现一个栈结构：-->先进后出，后进先出
相关文章
- 1. JavaSE基础知识——Day19 集合：List接口 、Set接口 、判断集合惟一性原理
- 2. JAVA_基础集合List接口与Set接口（二）
- 3. 类集---List接口与Set接口
- 4. 集合（二）：List接口。
- 5. Set集合接口
- 6. 接口List（集合）
- 7. Java Collection集合:List子类接口与Set子类接口
- 8. 整理List接口，Set接口，Map接口
- 9. Collection子接口之二： Set接口
- 10. Set接口
- 更多相关文章...
- • C# 接口（Interface） - C#教程
- • Kotlin 接口 - Kotlin 教程
- • ☆技术问答集锦（13）Java Instrument原理
- • 算法总结-滑动窗口
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
