Java中的集合详解及代码测试
1:对象数组
(1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
2:集合(Collection)
(1)集合的由来
我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
(2)集合和数组的区别
A:长度区别
数组固定
集合可变
B:内容区别
数组可以是基本类型，也可以是引用类型
集合只能是引用类型
C:元素内容
数组只能存储同一种类型
集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构
由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
Collection
|--List
|--ArrayList
|--Vector
|--LinkedList
|--Set
|--HashSet
|--TreeSet
(4)Collection的功能概述
A:添加功能
boolean add(E e)添加一个元素
boolean addAll(Collection<? extends E> c)添加一个集合的元素
B:删除功能
void clear()移除所有元素
boolean remove(Object o)移除一个元素
boolean removeAll(Collection<?> c)移除一个集合的元素
C:判断功能
boolean contains(Object o)如果此 collection 包含指定的元素，则返回 true
boolean containsAll(Collection<?> c)如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean isEmpty()如果此 collection 不包含元素，则返回 true。
D:获取功能
Iterator<E> iterator()返回在此 collection 的元素上进行迭代的迭代器
E:长度功能
int size()返回此 collection 中的元素数
F:交集(了解)
boolean retainAll(Collection<?> c)仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
G:把集合转数组(了解)
<T> T[] toArray(T[] a)返回包含此 collection 中所有元素的数组
import java.util.ArrayList;
import java.util.Collection; public class CollectioonDemo {
public static void main(String[] args) {
//创建对象
Collection c1 = new ArrayList(); //添加元素
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4"); Collection c2 = new ArrayList();
c1.add("abc4");
c2.add("abc5");
c2.add("abc6");
c2.add("abc7"); //c1.clear();//移除所有元素
//System.out.println("remove:" + c1.remove("abc1"));//remove:true
//System.out.println("remove:" + c1.remove("abc"));//remove:false //判断集合中是否包含指定元素
//System.out.println("contains:" + c1.contains("abc2"));//contains:true
//System.out.println("contains:" + c1.contains("abc"));//contains:false //判断是否为空
//System.out.println("isEmpty:" + c1.isEmpty());//isEmpty:false //元素个数
//System.out.println("size:" + c1.size());//size:5 //添加一个集合的元素
//System.out.println("addAll:" + c1.addAll(c2));//addAll:true
//System.out.println("c1:" + c1);//c1:[abc1, abc2, abc3, abc4, abc4, abc5, abc6, abc7] //移除一个集合的元素 只用有一个元素被移除了就返回true
//System.out.println("removeAll:" + c1.removeAll(c2)); //只有包含所有的元素才叫包含
//System.out.println("containsAll:" + c1.containsAll(c2)); //交集
/*
* A对B做交集，最终的结果保存在A中，B不变
* 返回值表示A是否发生过变化
*/
System.out.println("retainAll:" + c1.retainAll(c2));
System.out.println("c1:" + c1);
System.out.println("c2:" + c2); } }
(5)Collection集合的遍历
A:把集合转数组(了解)
实例1
import java.util.ArrayList;
import java.util.Collection; public class CollectioonDemo2 {
//集合变数组 实现集合的遍历
public static void main(String[] args) {
Collection c = new ArrayList(); c.add("hello");//Object obj = "hello" 向上转型
c.add("world");
c.add("java"); //集合c转数组
Object[] objs = c.toArray();
for(int x = 0;x < objs.length;x++){
System.out.println(objs[x]);
//object没有length()方法，必须将元素还原成字符串;向下转型
String s = (String) objs[x];
System.out.println(s+ "-----"+s.length());
}
} /*
* hello
hello-----5
world
world-----5
java
java-----4 */ }
实例2
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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;
}
}
import java.util.ArrayList;
import java.util.Collection; public class StudentDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList(); //创建学生对象
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 25);
Student s3 = new Student("王五", 26); //将学生对象添加到集合
c.add(s1);
c.add(s2);
c.add(s3); //集合转化为数组
Object[] obj = c.toArray(); //遍历数组
for(int i = 0; i < obj.length; i++){
Student s = (Student)obj[i];
System.out.println(s.getName() + "-------" + s.getAge());
} } }
B:迭代器(集合专用方式)
实例1
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; public class IteratorDemo {
public static void main(String[] args) { Collection c = new ArrayList(); c.add("java");
c.add("hello");
c.add("word");
c.add("hi"); Iterator it = c.iterator();
while (it.hasNext()){
String s = (String)it.next();
System.out.println(s);
} } }
实例2
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; public class ColectionTest {
public static void main(String[] args) { Collection c = new ArrayList(); Student s1 = new Student("貂蝉",25);
Student s2 = new Student("小乔",16);
Student s3 = new Student("黄月英",20);
Student s4 = new Student();
s4.setName("大桥");
s4.setAge(26); c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(new Student("孙尚香",18));//匿名对象 Iterator it = c.iterator();
while (it.hasNext()){
Student s = (Student)it.next();
System.out.println(s.getName() + "---" + s.getAge());
} } }
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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;
}
@Override
public String toString() {
return "Student [name = " + name + ", age = " + age +" ]";
}
}
(6)迭代器
A:是集合的获取元素的方式。
B:是依赖于集合而存在的。
C:迭代器的原理和源码。
a:为什么定义为了一个接口而不是实现类?
b:看了看迭代器的内部类实现。
(7)Collection集合的案例(遍历方式 迭代器)
集合的操作步骤：
A:创建集合对象
B:创建元素对象
C:把元素添加到集合
D:遍历集合
A:存储字符串并遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; /*
* 存储字符串并遍历
* 步骤：
* 1.创建集合对象
* 2.创建字符串对象
* 3.把字符串对象添加到集合
* 4.遍历集合
*/
public class CollectionTest {
public static void main(String[] args) {
//1.创建集合对象
Collection c = new ArrayList();
/*
* 创建字符串对象
* 把字符串对象添加到集合
*/
c.add("张三");
c.add("李四");
c.add("王五");
c.add("刘二");
//通过迭代器遍历集合
Iterator it = c.iterator();
//通过迭代器对象的hashNext()方法判断有没有元素
while(it.hasNext()){
//通过迭代器对象的next()方法获取元素
String s = (String) it.next();
System.out.println(s);
}
} }
B:存储自定义对象并遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; /*
* 存储自定义对象并遍历(Student name age)
* 步骤：
* 1.创建学生类
* 2.创建集合对象
* 3.创建学生对象
* 3.把学生对象添加到集合
* 4.遍历集合
*/
public class CollectionTest {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList(); //创建学生对象
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 21);
Student s3 = new Student("王五", 12);
//通过getset方法赋值
Student s4 = new Student();
s4.setName("刘二");
s4.setAge(22); //把学生对象添加到集合
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(new Student("小儿", 10));//匿名对象 //通过迭代器遍历集合
Iterator it = c.iterator();
//通过迭代器对象的hashNext()方法判断有没有元素
while(it.hasNext()){
//通过迭代器对象的next()方法获取元素
Student s = (Student) it.next();
System.out.println(s.getName()+ "-----" + s.getAge());
}
} }
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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;
}
}
3:集合(List)
(1)List是Collection的子接口
特点：有序(存储顺序和取出顺序一致)，可重复。
存储字符串并遍历：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; //List集合存储字符串并遍历
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList(); //创建字符串并添加到集合
list.add("hello");
list.add("world");
list.add("java"); //遍历集合
Iterator it = list.iterator();
while(it.hasNext()){
String s = (String) it.next();
System.out.println(s);
}
} }
测试有序可重复：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; /*
* List集合特点：有序（存储和取出的元素一直），可重复的
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList(); //创建字符串并添加到集合
list.add("hello");
list.add("world");
list.add("java");
list.add("java");
list.add("Linux");
list.add("java");
list.add("Linux"); //遍历集合
Iterator it = list.iterator();
while(it.hasNext()){
String s = (String) it.next();
System.out.println(s);
/*
* hello
world
java
java
Linux
java
Linux
*/
}
} }
存储自定义对象并遍历：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; /*
* 存储自定义对象并遍历
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList(); //创建学生对象
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 20);
Student s3 = new Student("王五", 24); //将学生对象添加到集合
list.add(s1);
list.add(s2);
list.add(s3); //遍历集合
Iterator it = list.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println(s.getName() + "-------" + s.getAge());
}
} }
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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;
}
}
(2)List的特有功能
A:添加功能
void add(int index, Object element)：在指定位置添加元素
B:删除功能
Object remove(int index)：根据索引删除元素，返回被删除的元素
C:获取功能
Object get (int index)：获取指定位置的元素
D:列表迭代器功能
ListItertor listIterator():list集合特有的迭代器
E:修改功能
Object set (int index，Object element)：根据索引修改元素，返回被修改的元素
public class ListDemo2 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//System.out.println("list:" + list);
/*
* list:[hello, world, java]
*/
//添加功能
//list.add(1, "linux");
//System.out.println("list:" + list);
/*
* list:[hello, linux, world, java]
*/
//获取功能
//System.out.println("get:" + list.get(2));
//get:java
//删除功能
//System.out.println("remove:" + list.remove(1));
//remove:world
//修改功能
System.out.println("set:" + list.set(1, "javaee"));
System.out.println("list:" + list);
/*
* set:world
list:[hello, javaee, java]
*/
}
}
(3)List集合的特有遍历功能
A:由size()和get()结合。
B:代码演示
import java.util.ArrayList;
import java.util.List; public class ListDemo1 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList(); //集合中添加元素
list.add("hello");
list.add("world");
list.add("java"); //遍历输出 list集合的特有遍历size()和get()结合
for(int x = 0; x < list.size(); x++){
String s = (String) list.get(x);
System.out.println(s);
}
}
}
自定义学生对象，两种遍历方式（迭代器和普通for）
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; /*
* 存储自定义对象，使用普通for 循环（get()size()方法结合）
*/
public class ListDemo1 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList(); //创建学生对象
Student s1 = new Student("张三", 12);
Student s2 = new Student("李四", 11);
Student s3 = new Student("王五", 20); //学生对象添加到集合
list.add(s1);
list.add(s2);
list.add(s3); //迭代器遍历
Iterator it = list.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println(s.getName() + "----" + s.getAge());
}
System.out.println("-----------");
//遍历输出 list集合的特有遍历size()和get()结合
for(int x = 0; x < list.size(); x++){
Student s = (Student) list.get(x);
System.out.println(s.getName() + "----" + s.getAge());
}
}
}
(4)列表迭代器的特有功能；(了解)
可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
(5)并发修改异常
A:出现的现象
迭代器遍历集合，集合修改集合元素
B:原因
迭代器是依赖于集合的，而集合的改变迭代器并不知道。
C:解决方案
a:迭代器遍历，迭代器修改(ListIterator)
元素添加在刚才迭代的位置
b:集合遍历，集合修改(size()和get())
元素添加在集合的末尾
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator; public class ListDemo2 { public static void main(String[] args) {
//创建List集合对象
List list = new ArrayList(); //添加元素
list.add("hello");
list.add("world");
list.add("java"); //迭代器遍历
// Iterator it = list.iterator();
// while(it.hasNext()){
// String s = (String) it.next();
// if("world".equals(s)){
// list.add("javaee");
// }
// }
/*
* ConcurrentModificationException
*/ //1.迭代器遍历元素，迭代器修改元素
//Iterator迭代器没有添加功能，使用它的子接口ListIterator
ListIterator lit = list.listIterator();
while(lit.hasNext()){
String s = (String)lit.next();
if("world".equals(s)){
list.add("javaee");
}
}//list:[hello, world,javaee, java] //2.集合遍历元素，集合修改元素（普通for）
// for(int x = 0; x < list.size(); x++){
// String s = (String) list.get(x);
// if("world".equals(s)){
// list.add("javaee");
// }
// }
System.out.println("list:" + list);
//list:[hello, world, java, javaee]
}
}
(6)常见数据结构
A:栈 先进后出
B:队列 先进先出
C:数组 查询快，增删慢
D:链表 查询慢，增删快
(7)List的子类特点
ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
到底使用谁呢?看需求?
分析：
要安全吗?
要：Vector(即使要，也不使用这个)
不要：ArrayList或者LinkedList
查询多；ArrayList
增删多：LinkedList
什么都不知道，就用ArrayList。
Java中的集合详解及代码测试的更多相关文章
- Java中日志组件详解
avalon-logkit Java中日志组件详解 lanhy 发布于 2020-9-1 11:35 224浏览 0收藏 作为开发人员,我相信您对日志记录工具并不陌生. Java还具有功能强大且功能强 ...
- java中的注解详解和自定义注解
一.java中的注解详解 1.什么是注解 用一个词就可以描述注解,那就是元数据,即一种描述数据的数据.所以,可以说注解就是源代码的元数据.比如,下面这段代码: @Override public Str ...
- [转载]java中import作用详解
[转载]java中import作用详解 来源: https://blog.csdn.net/qq_25665807/article/details/74747868 这篇博客讲的真的很清楚,这个作者很 ...
- Java中dimension类详解
Java中dimension类详解 https://blog.csdn.net/hrw1234567890/article/details/81217788
- JAVA中Object类方法详解
一.引言 Object是java所有类的基类,是整个类继承结构的顶端,也是最抽象的一个类.大家天天都在使用toString().equals().hashCode().waite().notify() ...
- Java中反射机制详解
序言 在学习java基础时,由于学的不扎实,讲的实用性不强,就觉得没用,很多重要的知识就那样一笔带过了,像这个马上要讲的反射机制一样,当时学的时候就忽略了,到后来学习的知识中,很多东西动不动就用反射, ...
- Java 中的泛型详解-Java编程思想
Java中的泛型参考了C++的模板,Java的界限是Java泛型的局限. 2.简单泛型 促成泛型出现最引人注目的一个原因就是为了创造容器类. 首先看一个只能持有单个对象的类,这个类可以明确指定其持有的 ...
- Java中Map用法详解
原文地址http://blog.csdn.net/guomutian911/article/details/45771621 原文地址http://blog.csdn.net/sunny2437885 ...
- Java中的多线程详解
如果对什么是线程.什么是进程仍存有疑惑,请先Google之,因为这两个概念不在本文的范围之内. 用多线程只有一个目的,那就是更好的利用cpu的资源,因为所有的多线程代码都可以用单线程来实现.说这个话其 ...
随机推荐
- Vue最常用的组件通讯有三种：父->子组件通讯、子->父组件通讯，兄弟组件通讯.(template用的pug模板语法)
Vue组件通讯 Vue最常用的组件通讯有三种:父->子组件通讯.子->父组件通讯,兄弟组件通讯.(template用的pug模板语法) 1.父->子组件通讯 父->子组件通 ...
- Linux内核设计与实现 总结笔记（第十五章）进程地址空间
一.地址空间 进程地址空间由进程可寻址的虚拟内存组成,内核允许进程使用这种虚拟内存中的地址. 每个进程都有一个32位或64位的平坦地址空间,空间的具体大小取决于体系结构.“平坦”指的是地址空间范围是一 ...
- PG_CONFIG-NOTFOUND
- 3D Computer Grapihcs Using OpenGL - 02 QGLWidget
用红色来填充GLWidget窗口 修改MyGlWindow.h,添加两个函数,一个用来初始化OpengGL,一个用来绘制OpenGL #pragma once #include <QtOpenG ...
- [洛谷P3938]:斐波那契(fibonacci)（数学）
题目传送门 题目描述 小$C$养了一些很可爱的兔子.有一天,小$C$突然发现兔子们都是严格按照伟大的数学家斐波那契提出的模型来进行繁衍:一对兔子从出生后第二个月起,每个月刚开始的时候都会产下一对小兔子 ...
- Java数据结构与算法(2):栈
栈是一种线性表,特点在于它只能在一个位置上进行插入和删除,该位置是表的末端,叫做栈的顶(top).因此栈是后进先出的(FIFO).栈的基本操作有push.peek.pop. 栈的示意图 进栈和出栈都只 ...
- ES6 二进制和八进制字面量
ES6 支持二进制和八进制的字面量,通过在数字前面添加 0o 或者 0O 即可将其转换为二进制值: let oValue = 0o10; console.log(oValue); // 8 let b ...
- Windows XP SP2上安装.net 4
1.安装 KB893803-v2-x86 2.安装dotnetfx35 3.安装dotNetFx40_Client_x86_x64 4.安装 NET Framework 4.0
- qcom Android Camera【转】
本文转载自:http://blog.csdn.net/Wilsonboliu/article/details/54949196 1.总体架构 Android Camera 框架从整体上看是一个 cli ...
- Laravel 的Artisan 命令学习
Laravel 的Artisan 命令学习 Artisan 是 Laravel 提供的 CLI(命令行接口),它提供了非常多实用的命令来帮助我们开发 Laravel 应用.前面我们已使用过 Artis ...