Day23-集合(上)
集合
概念
对象的容器，定义了多个对象进行操作的常用方法，可实现数组的功能。
和数组的区别
数组长度固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能存储引用类型
Collection集合
Collection父接口，该体系结构的根接口，代表一组对象，称为“集合”，每个对象都是该集合的元素
List接口特点：有序（有下标），元素可重复
Set接口特点：无序（无下标），元素不可重复（唯一）
List接口与实现类
常用：增加元素，删除元素，遍历元素，查找元素，判断
public class Student {
private String name;
private int age;
//无参构造，全参构造，get set方法，toString方法
/**
*
*/
public Student() {
super();
}
/**
* @param name
* @param age
*/
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;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
/*
list.remove(new Student("小红",16));删除需要重写equals对象，否则会认为创建了一个对象然后把它删了
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
return age == other.age && Objects.equals(name, other.name);
}
*/
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class TestStudent {
public static void main(String[] args) {
//创建集合
//因为List是接口，用它的子类实例化
List list = new ArrayList();
//添加元素
Student xm = new Student("小明",18);
Student xh = new Student("小红",16);
list.add(xm);
list.add(xh);
list.add(xh);
System.out.println("集合元素"+list.size());
System.out.println(list);
//删除元素
//list.remove(xh);//删一个，第一个小红没了
//还是3个，相当于又new另外一个，然后删除了
//如果想要删除，可以重写equals方法
list.remove(new Student("小红",16));
System.out.println("集合元素"+list.size());
//遍历元素
System.out.println("通过增强型for循环遍历：");
for (Object object : list) {
System.out.println(object);
}
System.out.println("通过for循环遍历：");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
//赋值强转成对象输出也可
//String str = (String)list.get(i);
//System.out.println(str);
}
System.out.println("通过迭代器遍历：");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
//Object object = (Object) iterator.next();
System.out.println(iterator.next());
}
System.out.println("通过列表迭代器遍历：");
ListIterator listIt = list.listIterator();
//既可以取元素，还可以取下标
while (listIt.hasNext()) {
System.out.println(listIt.nextIndex()+"-----"+listIt.next());
}
//正序输出完，可以逆序输出
while (listIt.hasPrevious()) {
System.out.println(listIt.nextIndex()+"-----"+listIt.previous());
}
//判断元素
System.out.println(list.contains(xm));
//判断是否为空
System.out.println(list.isEmpty());
//查找
System.out.println(list.get(0));
System.out.println(list.indexOf(xm));
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* List特点：有序、有下标、元素可以重复
*
*/
public class TestList1 {
public static void main(String[] args) {
List list = new ArrayList();
//1、添加元素
list.add("苹果");
list.add("香蕉");
list.add("西瓜");
list.add(0, "鸭梨");
list.add("西瓜");
System.out.println("元素个数："+list.size());
//集合对数组封装，重写toString方法
System.out.println(list);
/*
//2、删除元素
list.remove("苹果");
//根据下标移除
//list.remove(1);
//list.remove("西瓜");//删一个，第一个
System.out.println("元素个数："+list.size());
//删除所有
list.clear();
System.out.println("元素个数："+list.size());
*/
//3、遍历元素
System.out.println("通过for循环遍历：");
for (int i = 0; i < list.size(); i++) {
String str = (String)list.get(i);
}
System.out.println("增强for循环遍历：");
for (Object object : list) {
String str = (String)object;
System.out.println(str);
//不能一边遍历一边删除
//list.remove(str);
//可以遍历的同时设置
//list.set(0, "XXX");
}
System.out.println("通过迭代器循环遍历：");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String str = (String) iterator.next();
//System.out.println(iterator.next());错误的
System.out.println(str);
//iterator.remove();
}
System.out.println("通过列表迭代器循环遍历：");
ListIterator lisIt = list.listIterator();
//既可以取元素，还可以取下标
while (lisIt.hasNext()) {
System.out.println(lisIt.nextIndex()+"-----"+lisIt.next());
}
//开始不能逆向，开始时，下标还在第一个，先正向才可以逆向
System.out.println("逆向遍历：");
while (lisIt.hasPrevious()) {
System.out.println(lisIt.nextIndex()+"-----"+lisIt.previous());
}
//4、判断
//判断是否包含元素
System.out.println(list.contains("苹果"));
//判断是否为空
System.out.println(list.isEmpty());
//5、查找
System.out.println(list.get(0));
System.out.println(list.indexOf("苹果"));
}
}
import java.util.ArrayList;
import java.util.List;
public class TestList2 {
public static void main(String[] args) {
//创建集合
List list = new ArrayList();
//添加
list.add(10);//Integer
list.add(20);
list.add(30);
list.add(40);
System.out.println("元素个数"+list.size());
System.out.println(list);
//删除
//整数和下标一样，需要new一个包装类
list.remove(new Integer(10));
System.out.println("元素个数"+list.size());
}
}
ArrayList
import java.util.Objects;
public class Student {
private String name;
private int age;
/**
*
*/
public Student() {
super();
// TODO Auto-generated constructor stub
}
/**
* @param name
* @param age
*/
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
return age == other.age && Objects.equals(name, other.name);
}
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 + "]";
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class TestStudent {
public static void main(String[] args) {
//创建集合对象
ArrayList arrayList = new ArrayList();
//添加元素
Student s1 = new Student("张三",18);
Student s2 = new Student("李四",20);
Student s3 = new Student("王二麻子",17);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
System.out.println("元素个数："+arrayList.size());
System.out.println(arrayList);
//删除元素
arrayList.remove(new Student("张三",18));
System.out.println("元素个数："+arrayList.size());
//遍历元素
System.out.println("通过for循环遍历：");
for (int i = 0; i < arrayList.size(); i++) {
Student stu = (Student)arrayList.get(i);
//System.out.println(stu.getName()+"\t"+stu.getAge());
System.out.println(stu.toString());
}
System.out.println("通过增强型for循环遍历：");
for (Object object : arrayList) {
System.out.println(object);
}
System.out.println("通过迭代器遍历：");
//获取迭代器接口
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
System.out.println(object);
}
System.out.println("通过列表迭代器遍历：");
ListIterator liIt = arrayList.listIterator();
while (liIt.hasNext()) {
System.out.println(liIt.nextIndex()+"-----"+liIt.next());
}
System.out.println("逆向输出");
while (liIt.hasPrevious()) {
System.out.println(liIt.previousIndex()+"-----"+liIt.previous());
}
//判断元素
System.out.println(arrayList.contains(s2));
System.out.println(arrayList.isEmpty());
//查找元素
System.out.println(arrayList.get(0));
System.out.println(arrayList.indexOf(s3));
}
}
源码分析
/**
* ArrayList【重点】
* 数组结构实现，查询快，增删慢
*
* 特点：有序，有下标，可以重复
*
* 源码分析：
* 1.ArrayList无参构造方法中，创建了长度为0的数组。
* Object[] elementData={};
* 2.当添加第一个元素时，会将数组重新赋值长度为10的数组，并把元素放在数组中的第一个位置上。
* elementData=new Object[10];
* elementData[0]=e
* size++;
* 3.ArrayList每次扩容按1.5
* newCapacity = 10+ 10/2
int newCapacity = oldCapacity + (oldCapacity >> 1);移位
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class TestArrayList1 {
public static void main(String[] args) {
//创建集合
ArrayList arrayList = new ArrayList();
//添加元素
arrayList.add("苹果");
arrayList.add("香蕉");
arrayList.add("鸭梨");
System.out.println("元素个数"+arrayList.size());
System.out.println(arrayList);
//删除元素 删除一个
//arrayList.remove("苹果");
//根据下标移除
//arrayList.remove(0);
//System.out.println("元素个数"+arrayList.size());
//System.out.println(arrayList);
//清空
//arrayList.clear();
//System.out.println("元素个数"+arrayList.size());
//遍历元素
System.out.println("通过for循环遍历：");
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
System.out.println("通过增强型for循环遍历：");
for (Object object : arrayList) {
System.out.println(object);
}
System.out.println("通过迭代器循环遍历：");
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("通过列表迭代器循环遍历：");
ListIterator listIterator = arrayList.listIterator();
while (listIterator.hasNext()) {
System.out.println(listIterator.nextIndex()+"-----"+listIterator.next());
}
System.out.println("逆序循环遍历：");
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previousIndex()+"-----"+listIterator.previous());
}
//判断元素
System.out.println(arrayList.contains("苹果"));
System.out.println(arrayList.isEmpty());
//查询元素
System.out.println(arrayList.get(0));
System.out.println(arrayList.indexOf("苹果"));
}
}
LinkedList
源码分析
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
/**
* LinkedList：
链表结构实现，增删快，查询慢。
* 底层源码：
* 1 LinkedList每个元素封装成了Node类型（item,next,prev）
* 2 每添加一个元素，形成链表节点，修改last
*/
public class TestLinkedList {
public static void main(String[] args) {
//创建集合
LinkedList linkedList = new LinkedList();
//添加元素
Student s1 = new Student("张三",18);
Student s2 = new Student("李四",20);
Student s3 = new Student("王二麻子",17);
linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);
System.out.println("元素个数："+linkedList.size());
System.out.println(linkedList);
//删除元素
// linkedList.remove(s1);
// linkedList.clear();
// System.out.println("元素个数："+linkedList.size());
// System.out.println(linkedList);
//遍历元素
System.out.println("通过for循环遍历：");
for (int i = 0; i < linkedList.size(); i++) {
Student stu = (Student)linkedList.get(i);
System.out.println(stu);
}
System.out.println("通过增强型for循环遍历：");
for (Object object : linkedList) {
Student stu = (Student)object;
System.out.println(stu);
}
System.out.println("通过迭代器循环遍历：");
Iterator it = linkedList.iterator();
while (it.hasNext()) {
Student stu = (Student) it.next();
System.out.println(stu);
}
System.out.println("通过列表迭代器循环遍历：");
ListIterator listIterator = linkedList.listIterator();
while (listIterator.hasNext()) {
Student stu = (Student) listIterator.next();
System.out.println(stu);
}
System.out.println("逆序循环遍历：");
while (listIterator.hasPrevious()) {
Student stu = (Student) listIterator.previous();
System.out.println(stu);
}
//判断元素
System.out.println(linkedList.contains(s3));
System.out.println(linkedList.isEmpty());
//查询元素
System.out.println(linkedList.indexOf(s1));
}
}
Vector（基本弃用）
import java.util.Enumeration;
import java.util.Vector;
/**
* Vector：
数组结构实现，查询快、增删慢；
JDK1.0版本，运行效率慢、线程安全。
*
*/
public class TestVector {
public static void main(String[] args) {
//创建集合对象
//Object [] elementData = new Object[10];
Vector vector=new Vector();
//添加元素
vector.add("苹果");
vector.add("香蕉");
vector.add("鸭梨");
vector.addElement("西瓜");
System.out.println("元素个数："+vector.size());
System.out.println(vector);
//删除元素
// vector.remove(0);
// vector.remove("西瓜");
// System.out.println("元素个数："+vector.size());
// System.out.println(vector);
// vector.clear();
// System.out.println("元素个数："+vector.size());
//遍历元素
//for循环遍历
//增强for循环遍历
//迭代器遍历
//列表迭代器...同上
//枚举
Enumeration en=vector.elements();
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
}
//查找元素...同上
}
}
模拟栈和队列
import java.util.Stack;
/**
* 模拟栈
*/
public class TestStack {
public static void main(String[] args) {
//栈，先进后出
Stack stack = new Stack();
//进栈
System.out.println("进栈前的元素个数"+stack.size());
stack.push("苹果");
stack.push("香蕉");
stack.push("鸭梨");
System.out.println("元素个数"+stack.size());
//出栈
int count = stack.size();
for (int i = 0; i < count; i++) {
Object obj = stack.pop();
System.out.println(obj);
}
}
}
import java.util.LinkedList;
import java.util.Queue;
/**
* 模拟队列
*/
public class TestQueue {
public static void main(String[] args) {
//队列，先进先出
//是一个接口，不能直接new
Queue queue = new LinkedList();
//入队
System.out.println("元素个数："+queue.size());
queue.offer("苹果");
queue.offer("香蕉");
queue.offer("鸭梨");
System.out.println("元素个数："+queue.size());
System.out.println("出队");
int count = queue.size();
for (int i = 0; i < count; i++) {
System.out.println(queue.poll());
}
}
}
泛型
作者写的不错...
未完待续...
浙公网安备 33010602011771号