集合（一）
集合基础
- 集合概述
- 编程的时候如果要存储多个数据，使用长度固定的数组存储格式，不一定满足我们的需求，更适应不了变化的需求，那么，此时该如何选择？
- 集合的特点：
- 提供一个存储空间可变的存储模型，存储的数据容量可以发生改变。
- 集合之一：ArraysList
- ArraysList<E>:
- 可调整大小的数组实现
- <E>是一种特殊的数据类型，泛型。
- 使用方式
- 在出现E的地方使用数据类型替换即可。
- 如ArrayList<iStudent>,ArrayList<String>
- ArraysList构造方法和添加方法
package Arrays; import java.sql.SQLOutput; import java.util.ArrayList; /* ArrayList构造方法： public ArrayLisy(),创建一个空的集合过程 ArrayList添加方法： public boolean add(E e),将指定的元素追加到此集合的末尾 public void add(int index,E element),在此集合中的指定位置加入指定的元素 */ public class ArrayList1 { public static void main(String[] args) { // public ArrayList(),创建一个新的对象 // ArrayList<String> array = new ArrayList(); ArrayList<String> array = new ArrayList<String>(); // public boolean add(E e),将指定的元素追加到此集合的末尾 // System.out.println(array.add("hello")); array.add("hello"); array.add("world"); array.add("！"); // public void add(int index,E element),在此集合中的指定位置加入指定的元素 array.add(1,"java"); array.add(3,"javaEE"); // array.add(4,"java##");// 报错java.lang.IndexOutOfBoundsException: Index: 4, Size: 3 //输出集合 System.out.println("array" + array); } }
- ArrayList集合常用方法
package Arrays; import java.util.ArrayList; public class ArrayList2 { public static void main(String[] args) { ArrayList<String> array = new ArrayList<String>(); array.add("hello"); array.add("world"); array.add("java"); // 删除数组指定的元素 // System.out.println(array.remove("world")); 返回true // System.out.println(array.remove("jianw")); 返回flase； // 删除指定的元素，返回被删除的元素 // System.out.println(array.remove(1)); // System.out.println(array.remove(3)); java.lang.IndexOutOfBoundsException: Index: 3, Size: 3 // 修改指定索引处的元素，返回被删除的元素 // System.out.println(array.set(1,"javaee")); // 返回指定索引处的值 // System.out.println(array.get(0)); // System.out.println(array.get(1)); // System.out.println(array.get(2)); // 返回输出集合中的元素 System.out.println(array.size()); // 输出集合 System.out.println("array"+array); } }
集合类体系结构
Collecion集合
- Collection集合概述和使用
- 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
- JDK不提供接口的任何直接实现，它提供更具体的子接口(如Set和List)实现
- 创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
package Collection1; import java.util.ArrayList; import java.util.Collection; public class CollectionDemo1 { public static void main(String[] args) { // 创建Collection集合的对象 Collection<String> c = new ArrayList<String>(); // 添加元素，boolean add<E e> c.add("hello"); c.add("world"); c.add("java"); // 输出集合对象 System.out.println(c); } }
Collection集合常用方法
package Collection1; import java.util.ArrayList; import java.util.Collection; public class CollectionDemo2 { public static void main(String[] args) { Collection<String> c = new ArrayList<String>(); // 添加元素 // System.out.println(c.add("hello")); // System.out.println(c.add("world")); // System.out.println(c.add("world")); c.add("hello"); c.add("world"); c.add("java"); // 从集合移除指定元素 // System.out.println(c.remove("world")); // System.out.println(c.remove("javaEE")); // 清空集合中的元素 // c.clear(); // 判断集合中是否存在指定元素 // System.out.println(c.contains("world")); // System.out.println(c.contains("javaEE")); // 判断集合是否为空 // System.out.println(c.isEmpty()); // 集合的长度 System.out.println(c.size()); // 输出集合对象 System.out.println(c); } }
Collection集合的遍历
- iterator: 迭代器，集合的专用遍历方式
- iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
- 迭代器是通过集合的iterator()方法得到的，所以我们说他是依赖于集合而存在的
- iterator中的常用方法
- E next(): 返回迭代中的下一个元素
- boolean hasNext(): 如果迭代具有更多元素，则返回true
package Collection1; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionDemo3 { public static void main(String[] args) { Collection<String> c = new ArrayList<String>(); // 添加元素 c.add("hello"); c.add("world"); c.add("java"); // 返回此集合中的迭代器，通过集合的iterator()方法得到 Iterator<String> it = c.iterator(); /* public Iterator<E> iterator(){ return new Itr(); } private class Itr implements Iterator<E>{ 。。。 } */ // 获取元素 /* System.out.println(it.next()); System.out.println(it.next()); System.out.println(it.next()); System.out.println(it.next()); //java.util.NoSuchElementException 表示被请求元素不存在。 */ // 如果迭代具有更多元素，则返回true /* if (it.hasNext()){ System.out.println(it.next()); } if (it.hasNext()){ System.out.println(it.next()); } if (it.hasNext()){ System.out.println(it.next()); } if (it.hasNext()){ System.out.println(it.next()); } */ // 用while循环改进 while (it.hasNext()){ // System.out.println(it.next()); String s = it.next(); //可以对拿到的元素有更多的操作 System.out.println(s); } } }
Collection的使用步骤
- 步骤1：创建集合对象
- 步骤2：添加元素
- 步骤2.1：创建元素
- 步骤2.2：添加元素到集合
- 合并：添加元素到集合
- 步骤3：遍历集合
- 步骤3.1：通过集合对象获取迭代器对象
- 步骤3.2：通过迭代器对象的hasNext()方法判断是否还有元素
- 步骤3.3：通过迭代器对象的nexr()方法获取下一个元素。
Collection小案例
- 需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
- 思路
- 1.定义学生类
- 2.创建Collection集合对象
- 3.创建学生对象
- 4.把学生添加到集合
- 5.遍历集合（迭代器实现）
Student类
package Collection1; public class Student { private String name ; private int age; public Student(){}; public Student(String name, int age) { this.name = name; this.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; } }
CollectionTest类
public class CollectionTest1 { public static void main(String[] args) { Collection<Student> c = new ArrayList<Student>(); Student s1 = new Student("芜湖",21); Student s2 = new Student("yahu ",22); Student s3 = new Student("Sksa",23); c.add(s1); c.add(s2); c.add(s3); Iterator<Student> it = c.iterator(); while(it.hasNext()){ Student s = it.next(); System.out.println(s.getName()+","+s.getAge()); } } }
List集合
- List集合概述和特点
- List集合概述
- 有序集合（也称为序列），用户可以精确的控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素
- 与Set集合不同，列表通常允许重复的元素
- List集合特点
- 有序：存储和取出的元素顺序一致
- 可重复：存储的元素可以重复
public class ListDemo1 { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("hello"); list.add("world"); list.add("java"); list.add("world"); // System.out.println(list); Iterator<String> it = list.iterator(); while (it.hasNext()){ String n = it.next(); System.out.println(n); } } }
- List集合特有方法
package List; import java.util.ArrayList; import java.util.List; public class ListDemo2 { public static void main(String[] args) { //创建集合对象 List<String> list = new ArrayList<String>(); //添加元素 list.add("hello"); list.add("world"); list.add("java"); //在此集合中的指定位置加入指定的元素 // list.add(1,"javaee"); // list.add(11,"javaee");//IndexOutOfBoundsException: Index: 11, Size: 3 //删除指定索引处的元素，返回被删除的值 // System.out.println(list.remove(1)); // System.out.println(list.remove(11));.IndexOutOfBoundsException: Index: 11, Size: 3 //修改指定索引处的元素，返回被修改的元素 // System.out.println(list.set(1,"芜湖")); //返回指定索引处的元素 // System.out.println(list.get(1)); //输出集合对象 // System.out.println(list); //遍历集合 // System.out.println(list.get(0)); // System.out.println(list.get(1)); // System.out.println(list.get(2)); for (int i = 0; i <list.size() ; i++) { String s = list.get(i); System.out.println(s); } } }
List集合存储学生对象并遍历
package List; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* 需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合 思路 1.定义学生类 2.创建List集合对象 3.创建学生对象 4.把学生添加到集合 5.遍历集合（迭代器实现,for循环） */ public class ListDemo3 { public static void main(String[] args) { //创建LIst集合对象 List<Student> list = new ArrayList<Student>(); //创建学生对象 Student s1 = new Student("呀呼",21); Student s2 = new Student("一护",22); Student s3 = new Student("马武",23); //把学生添加到集合 list.add(s1); list.add(s2); list.add(s3); Iterator<Student> it = list.iterator(); while (it.hasNext()){ Student s = it.next(); System.out.println(s.getName()+","+s.getAge()); } System.out.println("-------------------------"); for (int i = 0; i <list.size() ; i++) { Student s = list.get(i); System.out.println(s.getName()+","+s.getAge()); } } }
并发修改异常
-
问题：现在我有一个集合，请问我想判断里面有没有"world"这个元素，如果有，我们就添加一个
"spark",怎么办呢？
- 并发修改异常
- ConcurrentModificationException 当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。
-
为什么会产生这种异常呢？
-
迭代器时依赖于集合存在的，在判断成功后，集合中添加了新的元素，而迭代器却不知道，所以就
报错了，这个叫做并发修改异常。
-
- 产生原因
- 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，这个问题反应的是，迭代器遍历元素的时候，集合是不能够修改元素的。
- 解决方案
- 用for循环遍历，然后用集合对象做对应的操作即可
-
迭代器遍历元素，迭代器修改元素添加的元素紧跟在刚刚迭代到的元素的后面
-
集合遍历元素，集合修改元素添加的元素是在最后一个
public class ListDemo7 { public static void main(String[] args) { //创建集合对象 List list = new ArrayList(); //添加元素到集合 list.add("hello"); list.add("world"); list.add("bigdata"); //将集合转换成迭代器 // Iterator i = list.iterator(); // while (i.hasNext()){ // Object next = i.next(); // String s = (String) next; // if("world".equals(s)){ // //ConcurrentModificationException // list.add("spark"); // } // } //迭代器遍历元素，迭代器修改元素 // ListIterator i = list.listIterator(); // while (i.hasNext()){ // Object next = i.next(); // String next1 = (String) next; // if("world".equals(next1)){ // i.add("spark"); // } // } //集合遍历元素，集合修改元素 for(int i =0;i<list.size();i++){ Object o = list.get(i); String s = (String) o; if("world".equals(s)){ list.add("spark"); } } System.out.println("---------------"); Iterator i1 = list.iterator(); System.out.println("遍历如下："); while (i1.hasNext()){ Object next = i1.next(); String s = (String) next; System.out.println(s); } } }
ListIterator
- ListIterator:列表迭代器
- 通过List集合的listiterator()方法得到，所以说他是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。
- ListIterator中的常用方法
- E next()：返回迭代中的下一个元素
- boolean hasNext(): 如果迭代具有更多元素，则返回true
- E previous(): 返回列表中的上一个元素
- boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
- void add(E e): 将指定元素插入列表
package List; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; /* ListIterator:列表迭代器 通过List集合的listiterator()方法得到，所以说他是List集合特有的迭代器 用于允许程序员沿任一方向遍历列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。 ListIterator中的常用方法 E next()：返回迭代中的下一个元素 boolean hasNext(): 如果迭代具有更多元素，则返回true E previous(): 返回列表中的上一个元素 boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true void add(E e): 将指定元素插入列表 */ public class ListIteratorDemo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("hello"); list.add("world"); list.add("java"); //通过List集合的listiterator()方法得到，所以说他是List集合特有的迭代器 // // ListIterator<String> lit = list.listIterator(); // while (lit.hasNext()){ // String s = lit.next(); // System.out.println(s); // } // System.out.println("------------------------------"); // // while (lit.hasPrevious()){ // String s = lit.previous(); // System.out.println(s); // } //获取列表迭代器 ListIterator<String> lit = list.listIterator(); while (lit.hasNext()){ String s = lit.next(); if (s.equals("world")){ lit.add("javaaaa"); } } System.out.println(list); } }
增强for循环
- 增强for : 简化数组和Collection集合的遍历
- 实现Iterable接口的类允许其对象成为增强型for语句的目标
- 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
- 增强for的格式
- 格式
- for(元素数据类型 变量名： 数组 或者Collection集合){
//在此处使用变量即可，该变量就是元素
}
- 范围：
- int[] arr = {1,2,3,4,5};
- for(int i : arr){
System.out.println(i);
}
package List; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; /* 增强for : 简化数组和Collection集合的遍历 实现Iterable接口的类允许其对象成为增强型for语句的目标 它是JDK5之后出现的，其内部原理是一个Iterator迭代器 增强for的格式 格式 for(元素数据类型 变量名 ： 数组 或者Collection集合){ //在此处使用变量即可，该变量就是元素 } */ public class ListFor1 { public static void main(String[] args) { int[] arr = {1,2,3,4,5}; for(int i : arr) { System.out.println(i); } System.out.println("-----------------------"); String[] strArray = {"hello","world","java"}; for (String s : strArray){ System.out.println(s); } System.out.println("------------------------"); List<String> list = new ArrayList<String>(); list.add("hello"); list.add("world"); list.add("java"); for (String s : list){ System.out.println(s); } // //内部原理是一个iterator迭代器 // for(String s : list){ // if (s.equals("world")){ // list.add("javaee"); //ConcurrentModificationException // } // } } }
List集合存储学生对象用三种方式遍历
package List; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /* 需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合 思路 1.定义学生类 2.创建List集合对象 3.创建学生对象 4.把学生添加到集合 5.遍历集合 迭代器：集合特有的遍历方式 普通for: 带有索引的遍历方式 增强for: 最方便的遍历方式 */ public class ListDemo5 { public static void main(String[] args) { List<Student> list = new ArrayList<Student>(); Student s1 = new Student("钟启航",21); Student s2 = new Student("芜湖",22); Student s3 = new Student("呀呼",24); list.add(s1); list.add(s2); list.add(s3); //迭代器，集合特有的遍历方式 Iterator<Student> it = list.iterator(); while (it.hasNext()){ Student s = it.next(); System.out.println(s.getName()+","+s.getAge()); } System.out.println("-------------------------"); for (int i = 0; i < list.size(); i++) { Student s = list.get(i); System.out.println(s.getName()+","+s.getAge()); } System.out.println("--------------------------"); for (Student s : list){ System.out.println(s.getName()+","+s.getAge()); } } }
LinkedList
- 底层数据结构是链表，查询慢，增删快
- 线程不安全，效率高
- LinkedList特有的功能：
- 1、添加功能：
- void addFirst(E e) 在该列表开头插入指定的元素。
- void addLast(E e) 将指定的元素追加到此列表的末尾。
- 2、获取参数：
- E getFirst() 返回此列表中的第一个元素。
- E getLast() 返回此列表中的最后一个元素。
- 3、删除功能：
- E removeFirst() 从此列表中删除并返回第一个元素。
- E removeLast() 从此列表中删除并返回最后一个元素。
- 1、添加功能：
package com.shujia.java.day16; import java.util.LinkedList; /* LinkedList的特有功能： 1、添加功能： void addFirst(E e) 在该列表开头插入指定的元素。 void addLast(E e) 将指定的元素追加到此列表的末尾。 2、获取参数： E getFirst() 返回此列表中的第一个元素。 E getLast() 返回此列表中的最后一个元素。 3、删除功能： E removeFirst() 从此列表中删除并返回第一个元素。 E removeLast() 从此列表中删除并返回最后一个元素。 错误：类型不能和java中工具类名相同 */ public class LinkedListDemo1 { public static void main(String[] args) { //创建集合对象 LinkedList list = new LinkedList(); //添加 list.add("hello"); list.add("world"); list.add("bigdata"); list.add("hadoop"); System.out.println(list); //void addFirst(E e) 在该列表开头插入指定的元素。 list.addFirst("spark"); //void addLast(E e) 将指定的元素追加到此列表的末尾。 list.addLast("flink"); System.out.println(list); //E getFirst() 返回此列表中的第一个元素。 Object first = list.getFirst(); String s = (String) first; System.out.println(s); //E getLast() 返回此列表中的最后一个元素。 Object last = list.getLast(); String last1 = (String) last; System.out.println(last1); //E removeFirst() 从此列表中删除并返回第一个元素。 Object o = list.removeFirst(); System.out.println((String)o); // Object first1 = list.getFirst(); // String s1 = (String) first1; // System.out.println(s1); System.out.println(list); //E removeLast() 从此列表中删除并返回最后一个元素。 Object o1 = list.removeLast(); System.out.println((String)o1); System.out.println(list); System.out.println(list); } }
- 经典面试题：
- 用LinkedList模拟栈数据结构的集合
package com.shujia.java.day16; import java.util.Iterator; import java.util.LinkedList; /* 请用LinkedList模拟栈数据结构的集合，并测试 题目的意思是： 自己自定义一个集合类，在这个集合内部可以使用LinkedList模拟 */ public class LinkedListDemo2 { public static void main(String[] args) { //模拟栈数据结构 //先进后出 //创建一个集合对象 // LinkedList list = new LinkedList(); // // //添加元素 //// list.add("hello"); //// list.add("bigdata"); //// list.add("hadoop"); // list.addFirst("hello"); // list.addFirst("bigdata"); // list.addFirst("hadoop"); // // //遍历 // Iterator iterator = list.iterator(); // while (iterator.hasNext()){ // String s = (String)iterator.next(); // System.out.println(s); // // } //如果你这么做 这道题0分 } }
以LinkedList集合为基础创建一个集合
package com.shujia.java.day16; import java.util.LinkedList; /* */ public class MyStack { private LinkedList list; public MyStack(){ list = new LinkedList(); } public void add(Object obj){ list.addFirst(obj); } public Object get(){ // return list.getFirst(); return list.removeFirst(); } public boolean isEmpty(){ return list.isEmpty(); } }
package com.shujia.java.day16; /* 对自己写的集合类进行测试 */ public class MyStackDemo { public static void main(String[] args) { //创建集合对象 MyStack m = new MyStack(); //添加元素 m.add("hello"); m.add("bigdata"); m.add("hadoop"); // System.out.println(m.get()); // System.out.println(m.get()); // System.out.println(m.get()); //NoSuchElementException //System.out.println(m.get()); while (!m.isEmpty()){ System.out.println(m.get()); } } }
Vector
- Vector的特有功能：
- 1、添加功能：
- void addElement(Object obj) 将指定的组件添加到此向量的末尾，将其大小增加1。
- 2、获取功能：
- Object elementAt(int index) 返回指定索引处的元素 --get()
- Enumeration elements() 返回此向量的组件的容器。--list.iterator()
- boolean hasMoreElements() 测试此容器是否包含更多元素。 --hasNext()
- E nextElement() 如果此容器对象至少有一个要提供的元素，则返回此容器的下一个元素。
- --next()
- 1、添加功能：
package com.shujia.java.day16; import java.util.Enumeration; import java.util.Vector; /* Vector的特有功能： 1、添加功能： void addElement(Object obj) 将指定的组件添加到此向量的末尾，将其大小增加1。 2、获取功能： Object elementAt(int index) 返回指定索引处的元素 --get() Enumeration elements() 返回此向量的组件的容器。--list.iterator() boolean hasMoreElements() 测试此容器是否包含更多元素。 --hasNext() E nextElement() 如果此容器对象至少有一个要提供的元素，则返回此容器的下一个元素。 --next() */ public class VectorDemo3 { public static void main(String[] args) { //创建集合对象 Vector v = new Vector(); //添加功能 v.addElement("hello"); v.addElement("world"); v.addElement("bigdata"); v.addElement("hadoop"); //遍历 Enumeration elements = v.elements(); while (elements.hasMoreElements()){ Object o = elements.nextElement(); String o1 = (String) o; System.out.println(o1); } //for循环遍历 System.out.println("------------"); for(int i=0;i<v.size();i++){ Object o = v.elementAt(i); String o1 = (String) o; System.out.println(o1); } } }
浙公网安备 33010602011771号