List接口的特有方法
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):获取指定索引处的元素,并返回该元素 |
引言思路:
简单引出 |
引言示例:我们刚才说了List体系有个很重要特点是什么?就是有索引,下面我们来看下List特有方法也就是与索引有关的方法
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迭代过程中可能会发生的错误情况。 |
1.4数据的存储结构
A:数据的存储结构
a:栈结构:后进先出/先进后出(手枪弹夹) FILO (first in last out) b:队列结构:先进先出/后进后出(银行排队) FIFO(first in first out) c:数组结构: 查询快:通过索引快速找到元素 增删慢:每次增删都需要开辟新的数组,将老数组中的元素拷贝到新数组中 开辟新数组耗费资源 d:链表结构 查询慢:每次都需要从链头或者链尾找起 增删快:只需要修改元素记录的下个元素的地址值即可不需要移动大量元素 |
引言思路:
简单引出 |
引言示例:小插曲说完之后,我们再来看下集合中所涉及到一些数据结构,我们会讲四种数据结构,数组,链表,栈和队列,大家关键记着四种数据结构的特点就OK了,我们来看下
08Vector类的特点
ArrayList集合的自身特点
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的长度的新数组 //把原数组中的元素拷贝到新数组,再把最后一个元素添加到新数组中 原数组: 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 |
我们大致看了下集合中一些方法的使用,下面我们重点学习下集合特有的遍历方式就是使用迭代器,先来简单了解下迭代器的由来 |
引言示例:说完集合涉及到的数据结构,下面我们来单独看下它的儿子,首先说一个最常用的ArrayList,底层使用的是数组,数组结构,查询和增删方面的特点
2.2 LinkedList集合的自身特点
|
引言思路:
简单引出 |
引言示例:刚才我们知道ArrayList增删慢,查询快,下面我们学习另外一个儿子LinkedList
底层使用链表结构,而它的特点和ArrayList正好相反,我们来看下为什么.
2.3 LinkedList特有方法
*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);
} } |
引言思路:
简单引出 |
引言示例:Array List的特有方法都是与索引有关,那么LinkedList呢?它的一些特有方法都是操作链头或者链尾方法,我们简单了解下就OK
2.4 Vector类的特点
*A:Vector类的特点
Vector集合数据存储的结构是数组结构,为JDK中最早提供的集合,它是线程同步的 Vector中提供了一个独特的取出方式,就是枚举Enumeration,它其实就是早期的迭代器。 此接口Enumeration的功能与 Iterator 接口的功能是类似的。 Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。 |
引言思路:简单引出
简单引出。 |
引言示例:下面我们学习List最后一个儿子,元老级的人物,不过不用它,它被ArrayList替代了,我们简单了解下它的特点就OK
3.1 Set接口的特点
A:Set接口的特点
a:它是个不包含重复元素的集合。 b:Set集合取出元素的方式可以采用:迭代器、增强for。 c:Set集合有多个子类,这里我们介绍其中的HashSet、LinkedHashSet这两个集合。 |
引言思路:
简单引入 |
引言示例:List体系我们学到这里,大家关键记住ArrayList,LinkedList和Vector的特点,特有的方法下去简单练下,忘了在回头去查就OK,我们下面来看下Set体系,我们也来看看Set体系整体有什么特点
3.2 Set集合存储和迭代
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); } } } |
引言思路:
简单引入 |
引言示例:我们来看下使用Set集合如何存储和遍历元素,如何往Set中添加元素,这时候就要看父亲有没有添加方法?有啊还是add,父类中定义了iterator,所有的Collection儿子都能使用迭代器迭代.
3.3哈希表的数据结构
A:哈希表的数据结构:(参见图解)
加载因子:表中填入的记录数/哈希表的长度 例如: 加载因子是0.75 代表: 数组中的16个位置,其中存入16*0.75=12个元素 如果在存入第十三个(>12)元素,导致存储链子过长,会降低哈希表的性能,那么此时会扩充哈希表(在哈希),底层会开辟一个长度为原长度2倍的数组,把老元素拷贝到新数组中,再把新元素添加数组中
当存入元素数量>哈希表长度*加载因子,就要扩容,因此加载因子决定扩容时机 |
引言思路:
简单引入 |
引言示例:下面我们从它的第一个儿子来入手,HashSet,它底层用什么数据结构呢?Hash单词突出底层使用的是哈希表结构,我们就先来学习下哈希表结构到底是什么样子,大家有个大致印象就OK
3.4字符串对象的哈希值
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; } |
引言思路:
简单引入 |
引言示例: HashSet底层就会形成这种哈希表结构,有个大致印象就OK,那么HashSet是如何保证唯一的呢?他依托于两个方法hashCode()方法和equals()方法,我们先来研究下hashCode()方法
3.5 哈希表的存储过程
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,说明没有重复,存入 |
引言思路:
简单引入 |
引言示例:我们知道hashCode()返回一个是十进制的值,我们把这个值叫做哈希值,不同的类都会重写Object类的hashCode()方法,底层有不同的生成哈希值的算法,我们知道就OK,我们下面来研究下,到底如何通过hashCode()方法和equals()方法保证存入HashSet的值唯一的
4.1哈希表的存储自定义对象
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; } } |
引言思路:
简单引出。 |
引言示例: 刚才我们存储的是字符串,我们如果存储自定义的对象呢?那么效果会是什么样子呢?
4.2自定义对象重写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; } } |
引言思路:
简单引入 |
引言示例:如果你要存自定义对象我们都会重写掉自定义对象所属类的hashCode()方法和equals()方法,单纯的比较内存地址值没有实际意义,我们看下如何去重写
4.3 LinkedHashSet集合
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); } } |
引言思路:
衔接视频中的开头内容,简单说明 |
引言示例:对于hashSet我们记着它保证唯一性的原理就可以了,就是通过hashCode()方法和equals()方法来保证唯一,下面我们在看另外一个儿子LinkedHashSet,多加一个Linked,它相对与HashSet多点什么功能呢?
4.4 ArrayList,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方法。 |
引言思路:
结合视频开始,说出引言 |
引言示例:最后给大家补充两个小的知识点就是List的contains方法底层如何去判断?
还有Set的add()方法返回值什么时候返回true,什么时候返回false?
4.5 hashCode和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 |