个人整理非商业用途，欢迎探讨与指正！！
? 上一篇
反复反馈的过程,通常就是为了获取结果使用的。迭代和遍历是类似的
每次迭代都是重复的过程,每次迭代的结果作为下一次的初始值
迭代器是传统的遍历方式,JDK1.5之前使用
迭代器的方法
?hasNext:判断迭代器是否有下一个元素
?next:获取当前游标对应的元素,将游标向后移动一位
?remove:移除当前迭代器中的数据
public class Demo02 {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("hello");
coll.add(new Integer(10));
coll.add(20);
coll.add("bmh");
// 可以通过集合获取迭代器
// 迭代器可以帮我们进行集合的遍历(JDK1.5之前)
Iterator iterator = coll.iterator();
// 判断当前是否有元素
while(iterator.hasNext()) {
// 获取当前,向后移位
System.out.println(iterator.next());
}
}
}
迭代器的常见问题:
?1.迭代器是一个一次性的工具,迭代完成之后,游标会停到最后一位,就不能在向下了,迭代器空了没有数据了
?2.迭代时每次循环不能调用多次next(),若想调用多次,数据是next()的倍数,否则抛出NoSuchElementException
?3.迭代时不要向集合中添加或者删除元素,会抛出ConcurrentModificationException(并发修改异常)
public class Demo02 {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("hello");
coll.add(new Integer(10));
coll.add(20);
coll.add("bmh");
coll.add("bmh");
// 可以通过集合获取迭代器
// 迭代器可以帮我们进行集合的遍历(JDK1.5之前)
Iterator iterator = coll.iterator();
// 判断当前是否有元素
/*while(iterator.hasNext()) {
// 获取当前,向后移位
System.out.println(iterator.next());
}*/
System.out.println("------------------------");
// 第二次迭代
/*while(iterator.hasNext()) {
System.out.println(iterator.next());
}*/
System.out.println("------------------------");
/*while(iterator.hasNext()) {
// 获取当前,向后移位
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println("=======");
}*/
System.out.println("------------------------");
while(iterator.hasNext()) {
// 向集合中添加元素
coll.add("hi");
// 获取当前,向后移位
System.out.println(iterator.next());
}
}
}
Java中的菱形语法:<>
JDK1.5后引入
参数化类型,可以擦除数据类型,消除向下造型
集合都是泛型类或者泛型接口
public class Demo03 {
public static void main(String[] args) {
// 泛型写Object及其任意的子类(基本类型不能写)
// 前后的类型需要一致,或者前写后不写,默认和前是一致的
// Collection<Integer> coll = new ArrayList<Integer>();
// 泛型添加之后,规范化了类型,如下:当前的集合中只能添加Integer类型
Collection<Integer> coll = new ArrayList<>();
// 规定好了类型
// coll.add("hello");
coll.add(10);
coll.add(20);
// 集合都是泛型类或者接口 Iterator迭代器也是集合
Iterator<Integer> iterator = coll.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
Collection<String> coll1 = new ArrayList<>();
coll1.add("helloworld");
coll1.add(new String("你好世界"));
Iterator<String> it = coll1.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
List接口的实现类
底层使用数组完成
常用方法:
add(int index, E element) 向集合指定下标中添加元素
add(E e) 在集合的尾部添加元素
get(int index) 通过下标返回指定位置的元素
set(int index, E element) 设置修改,修改的指定下标的内容
listIterator() 获取list专属迭代器
subList(int fromIndex, int toIndex) 集合的截取,从fromIndex到toIndex(不包含)结束
public class Demo04 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
// 添加
list.add("张三");
list.add("李四");
list.add("王五");
// toString是重写过的
System.out.println(list.toString());
// 在指定位置进行添加元素
list.add(0, "赵六");
System.out.println(list);
// 下标需要在范围之内
// list.add(-1,"小七");
// list中可以添加null值
list.add(null);
System.out.println(list);
// 清空
/*list.clear();
System.out.println(list);*/
// 返回下标
System.out.println(list.indexOf("张三"));
System.out.println(list.indexOf(null));
// 是否包含
System.out.println(list.contains("李四"));
// 通过下标移除 返回结果为刚刚被删除的数据
System.out.println(list.remove(0));
System.out.println(list);
// 修改集合的内容 返回的是原本的值
System.out.println(list.set(0, "wch"));
System.out.println(list);
// 获取方法
System.out.println(list.get(0));
// 集合的截取
List<String> subList = list.subList(0, 2);//返回值是List的一个实现类型中的内部类(继承了AbstractList的)
System.out.println(subList);
}
}
有三种方式
?1.迭代器
?2.foreach循环
?3.for循环(只能遍历list集合)
public class Demo05 {
// list集合的遍历
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张三");
list.add("李四");
list.add("王五");
// 1.迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
ListIterator<String> it1 = list.listIterator();
// 向下:下面是否有内容
while(it1.hasNext()) {
System.out.println(it1.next());
}
System.out.println("+++++++++++++++++++++++++");
// 向上:上面是否有内容
while(it1.hasPrevious()) {
System.out.println(it1.previous());
}
System.out.println("-------------------------");
// 2.foreach
for (String string : list) {
System.out.println(string);
}
System.out.println("-------------------------");
// 3.普通for循环
for(int i = 0;i<list.size();i++) {
System.out.println(list.get(i));
}
}
}
ArrayList的底层是数组实现的,所有它有一些数组的特征(下标)
数组结构的特点:1.查询快,2.增删慢
add(E e)方法:
?1.若为一次添加元素,那么将底层的空数组进行扩容默认是10,默认的容器可以手动的指定(调用的ArrayList的带参构造)
?2.若不为第一次添加元素,当有效个数为size+1,大于数组(底层默认的数组)的长度了就需要扩容
?3.每次的扩容为原来的1.5倍(oldCapacity + (oldCapacity >> 1))
?ps:移位运算符,是最快速的运算符
??①a>>b 等价与 a / 2的b次方
??②a<<b 等价与 a * 2的b次方
add(int index,E e)方法:
?1.检测下标的范围是否合法
?2.判断是否需要扩容
?3.将原数组的index下标位向后拷贝
?4.在index下标位添加新元素e
?5.有效个数++
get(int index)方法:
?1.判断下标是否合法
?2.返回指定位置的元素
…
api和ArrayList类似,有自己独特的添加首尾的方法
底层使用的双链表实现的
public class Demo06 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
// 方法 默认是添加到最后的
list.add("张三");
list.add("李四");
list.add("王五");
System.out.println(list);
// 添加到结尾
list.addLast("赵六");
System.out.println(list);
// 添加到头部
list.addFirst("李二");
System.out.println(list);
// 获取头和尾
System.out.println(list.getFirst());
System.out.println(list.getLast());
// 和ArrayList类似的方法
System.out.println(list.get(3));
}
}
可以模拟栈和队列的数据结构
栈:先进后出
队列:先进先出
public class Demo07 {
public static void main(String[] args) {
// 模拟栈
LinkedList<String> list = new LinkedList<>();
// 入栈:先进后出
// 调用addFirst
list.push("张三");//先进入的存在最后
list.push("李四");
list.push("王五");
list.push("赵六");
System.out.println(list.get(0));
System.out.println(list);
// 出栈:将数据移除
list.pop();//赵六出栈
list.pop();//王五出栈
list.pop();//李四出栈
list.pop();//张三出栈
System.out.println(list);
System.out.println("--------------------------------");
// 模拟队列
// 调用add(默认添加到尾部)
list = new LinkedList<>();
list.offer("张三");
list.offer("李四");
list.offer("王五");
list.offer("赵六");
System.out.println(list);
// 出列
list.poll();//张三
list.poll();//李四
list.poll();//王五
list.poll();//赵六
System.out.println(list);
}
}
底层选用双链表结构
数据结构中存在表结构
?顺序表:内存空间是连续的,数组,允许随机访问,尾插和尾删方便,优点:查询快;缺点:插入的效率低,删除效率低,长度固定(查快,删改慢)
?单链表:内存不是连续的,可以随意的增删改,查询效率低,应用:HashSet,HashMap
??单链表只能下一个
?双链表:和单链表类似,内存不连续,查询效率比单链表快一倍,但查询效率仍然是低的,应用:LinkedList
??双链表可以下一个,也可以上一个
//LinkedList双链表的源码
private static class Node<E> {
E item;//当前元素
Node<E> next;//下一个元素
Node<E> prev;//上一个元素
//构造方法
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
与ArrayList方法基本一样
底层同样使用的是数组
Vector是线程安全的,底层中只要有synchronized关键字就是线程安全的
?线程安全都是效率低
创建时底层数据的默认长度为10
和ArrayList有一定的区别,默认长度是0,第一次添加数据时才会扩容到10
查询快,在不考虑线程安全时使用ArrayList,考虑时使用Vector
public class Demo08 {
public static void main(String[] args) {
Vector<String> v = new Vector<>();
v.add("张三");
v.add("李四");
System.out.println(v);
v.remove("张三");
System.out.println(v);
// 通过下标移除
v.remove(0);
System.out.println(v);
v.remove("");
}
}
Set集合的主要实现类之一
特点:无序(插入无序),无下标,不可重复,只能添加一个null值
常用的方法和Collection接口中基本一致
public class Demo09 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("张三");
set.add("李四");
set.add("王五");
// 取出顺序和添加顺序无关:无序
System.out.println(set);
// 没有下标
// set.get(0);
// 不可重复
set.add("张三");
System.out.println(set);
// 可以添加null值,但是只能加入一个
set.add(null);
set.add(null);
System.out.println(set);
}
}
无序:只是添加和set集合的存放是不一样的
在存储时内部是有一套自己的方案的,按照hash值进行存放的
public class Demo10 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
// 0~9的hash值是连续的
// 无序并不是杂乱无章的,只是添加和存储的顺序不一样
set.add("1");
set.add("7");
set.add("2");
set.add("3");
set.add("4");
set.add("8");
set.add("0");
set.add("5");
set.add("9");
set.add("6");
System.out.println(set);
}
}