标签：Java System 集合 add 初学 day12 println c1 out
java 12
集合
1、Collection
到目前位置，我们学习过哪些可以存储元素的容器
1、数组
优点：不同的数组可以存储不同数据类型的元素
缺点：长度不可变
2、StringBuffer|StringBuilder
优点：长度可以跟随元素的数量而改变
缺点：里面的元素只有一种字符数据类型
我们今后会根据元素的是否重复，存储和取出的顺序等来决定我们该使用什么样的容器来进行存储
根据我现实生活中经验来说，容器应该是丰富多彩的，多种多样的
java应该要使用若干个不同的类来描述不同的容器，表示不同容器的特点。
容器应该都有若杠共同的特点，都可以装东西等。
那么java中提供的这些类中成员应该也会有相同的部分，那我们将其向上提取，由继承或实现来构建关系
这样我们就可以得到一个继承体系。
Collection【接口】:
我们通过帮助文档发现，Collection是一个接口，不能直接new对象
根据元素是否可以发生重复，继续分类
- List【接口】元素可以发生重复，且有索引的概念
ArrayList
- Set【接口】元素不可以发生重复，没有索引
借助ArrayList子类对象来使用Collection接口中的方法
学习java中任意一个集合的步骤：
1、创建相关集合对象
2、创建元素对象
3、将元素添加到集合中
4、遍历集合
Collection中的成员方法：
一
boolean add(E e) //向集合中添加元素
boolean remove(Object o) //在集合中删除元素
void clear() //清空集合
boolean contains(Object o) //查找集合中是否包含某元素
boolean isEmpty() //验证该集合是否为空
int size() //获取集合的长度
public class CollectionDemo1 {
public static void main(String[] args) {
//借助ArrayList创建对象来使用Collection接口中的方法
// 1、创建相关集合对象
Collection c1 = new ArrayList();
//boolean add(Object e)
c1.add(100); //这里涉及到自动装箱 int -> Integer
c1.add(true);
c1.add(12.34);
c1.add(1000L);
c1.add(100);
c1.add(12.34);
// 重写toString()方法的类是ArrayList类的父类的父类中重写的。
// 底层是使用StringBuilder实现的
System.out.println("c1: " + c1);
//注意：我们今后使用集合的时候，规定一个集合只能存储一种数据类型的元素
System.out.println("-----------------------------------------");
//[100, true, 12.34, 1000, 100, 12.34]
//boolean remove(Object o) 从集合中删除一个元素,只会删除最左边的一个匹配元素
c1.remove(100);
System.out.println("c1: " + c1);
System.out.println("-----------------------------------------");
//void clear() 清空集合元素
// c1.clear();
// System.out.println("c1: " + c1);
System.out.println("-----------------------------------------");
//boolean contains(Object o) 判断Collection集合中是否包含某个元素
System.out.println(c1.contains(12.34));
System.out.println("-----------------------------------------");
//boolean isEmpty() 判断Collection集合是否为空
System.out.println(c1.isEmpty());
System.out.println("-----------------------------------------");
//int size() 获取集合的长度【元素的个数】
System.out.println(c1.size());
}
}
二
boolean addAll(Collection c) //向集合中添加集合c
boolean removeAll(Collection c) //在集合中删除集合c
boolean containsAll(Collection c) //判断集合中是否包含集合c
boolean retainAll(Collection c) //求该集合与集合c的交集
public class CollectionDemo2 {
public static void main(String[] args) {
//创建集合对象
Collection c1 = new ArrayList();
c1.add("java");
c1.add("maven");
c1.add("clickhouse");
c1.add("redis");
Collection c2 = new ArrayList();
c2.add("java");
c2.add("hadoop");
c2.add("maven");
c2.add("hive");
c2.add("hbase");
c2.add("数据采集");
System.out.println("c1: "+c1);
System.out.println("c2: "+c2);
System.out.println("------------------------------");
//boolean addAll(Collection c)
// c1.addAll(c2);
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
//boolean removeAll(Collection c)
// c1.removeAll(c2);
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
//boolean containsAll(Collection c)
// System.out.println(c1.containsAll(c2));
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
//boolean retainAll(Collection c) 求交集 将结果保存在调用方法的对象集合中
c1.retainAll(c2);
System.out.println("c1: "+c1);
System.out.println("c2: "+c2);
}
}
问题：如何遍历一个集合
方法一：Object[] toArray() 把集合转成数组，可以实现集合的遍历
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
c1.add("world");
Object[] objects = c1.toArray();
for(int i=0;i<objects.length;i++){
Object obj = objects[i]; // "hello"
String s = (String)obj;
//向下转型，才可使用元素自己类型的方法
System.out.println(s+"-"+s.length());
}
}
}
方法二：Iterator iterator() 迭代器，集合的专用遍历方式
public class CollectionDemo4 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
c1.add("world");
//Collection类型的集合本身是不可以直接遍历的
//需要生成对应的迭代器，迭代器中存储了集合中的元素
//将来遍历迭代器就可以获取集合中的元素了
//生成迭代器
Iterator iterator = c1.iterator(); // new Itr()
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next()); // NoSuchElementException
//每一个迭代器，都有一个独立指针，每调用一次next()方法，就会向后移动一次指针取数据
//如何判断下一个位置上是否有元素呢？
while (iterator.hasNext()){
Object obj = iterator.next();
String s = (String)obj;
System.out.println(s+"-"+s.length());
}
}
}
运用
/*
Collection集合存储自定义对象
1、创建集合对象
2、创建元素对象
3、将元素添加到集合中
4、遍历集合
*/
public class CollectionDemo5 {
public static void main(String[] args) {
//1、创建集合对象
Collection c1 = new ArrayList();
//2、创建元素对象
Student s1 = new Student("李刚", 15);
Student s2 = new Student("江川", 11);
Student s3 = new Student("钱志强", 17);
Student s4 = new Student("祝帅", 15);
// 3、将元素添加到集合中
c1.add(s1);
c1.add(s2);
c1.add(s3);
c1.add(s4);
// 4、遍历集合
//方式1：转数组遍历
// Object[] objects = c1.toArray();
// for(int i=0;i<objects.length;i++){
// Object obj = objects[i];
// Student s = (Student) obj;
// System.out.println(s.getName()+"-"+s.getAge());
// }
//方式2：迭代器遍历
Iterator iterator = c1.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
Student s = (Student) obj;
System.out.println(s.getName()+"-"+s.getAge());
}
}
}
2、List集合
List集合：元素可以发生重复，有序(指存储和取出的顺序一致)
Collection【接口】：
- List【接口】
ArrayList
- Set【接口】
List集合中特有的成员方法：
void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element)
ListIterator listIterator()
public class ListDemo1 {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("hello");
list1.add("apple");
list1.add("banana");
list1.add("watermelon");
list1.add("mango");
System.out.println("list1: " + list1);
System.out.println("==================================");
//因为List相关集合具备索引的特点，List集合根据索引提供一些其它集合没有的方法
//void add(int index,E element) 指定索引位置添加元素 grape
list1.add(2,"grape");
System.out.println("list1: " + list1);
System.out.println("==================================");
// E remove(int index) 根据索引从集合中移除元素
System.out.println(list1.remove(2));
System.out.println("list1: " + list1);
System.out.println("==================================");
//E get(int index) 根据索引获取对应元素
System.out.println(list1.get(3));
System.out.println("list1: " + list1);
System.out.println("==================================");
//E set(int index,E element) 指定索引位置修改元素
System.out.println(list1.set(3, "orange"));
System.out.println("list1: " + list1);
System.out.println("==================================");
//ListIterator listIterator()
ListIterator listIterator = list1.listIterator();
//从前向后取
while (listIterator.hasNext()){
System.out.println(listIterator.next());
}
System.out.println("==================================");
//从后向前取
//注意：一个集合迭代器只有一个游标，要想倒着遍历，必须先正着遍历一遍，所以该方法用的较少
while (listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
}
问题：
/*
需求：遍历集合，当遇到mango的时候，向集合中添加一个元素"java"
我们发现如果使用迭代器遍历，集合发生修改的话，报错了
ConcurrentModificationException
*/
public class ListDemo2 {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("hello");
list1.add("apple");
list1.add("banana");
list1.add("watermelon");
list1.add("mango");
list1.add("peach");
list1.add("pear");
System.out.println("list1: " + list1);
System.out.println("======================================");
//1、转数组遍历
// Object[] objects = list1.toArray();
// for(int i=0;i<objects.length;i++){
// Object obj = objects[i];
// String s = (String) obj;
// if("mango".equals(s)){
// list1.add("java");
// }
// }
// System.out.println("list1: "+list1);
// System.out.println("======================================");
//2、使用迭代器遍历
// Iterator iterator = list1.iterator();
// while (iterator.hasNext()){
// Object obj = iterator.next();
// String s = (String) obj;
// if("mango".equals(s)){
// list1.add("java");
// }
// }
// System.out.println("list1: "+list1);
//使用List集合中特有的迭代器进行遍历比较，且使用它进行添加元素
ListIterator listIterator = list1.listIterator();
while (listIterator.hasNext()) {
Object obj = listIterator.next();
String s = (String) obj;
if ("mango".equals(s)) {
listIterator.add("java");
}
}
System.out.println("list1: " + list1);
}
}
ArrayList迭代器源码
public interface List extends Collection{}
class ArrayList implements List{
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
Itr() {}
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
}
标签：Java,
System,
集合,
add,
初学,
day12,
println,
c1,
out
From： https://www.cnblogs.com/qianzhiqiang798/p/18470581