目录
第九章容器
1.容器
数组就是一种容器,可以在其中放置对象或基本类型数据。
数组的优势:是一种简单的线性序列,可以快速地访问数组元素,效率高。如果从效率和类型检查的角度讲,数组是最好的。
数组的劣势:不灵活。容量需要事先定义好,不能随着需求的变化而扩容。比如:我们在一个用户管理系统中,要把今天注册的所有用户取出来,那么这样的用户有多少个?我们在写程序时是无法确定的。因此,在这里就不能使用数组。
基于数组并不能满足我们对于“管理和组织数据的需求”,所以我们需要一种更强大、更灵活、容量随时可扩的容器来装载我们的对象。 这就是容器,也叫集合。
2.泛型
泛型的本质是“数据类型的参数化”。就是将原来的具体的类型参数化,然后调用此方法时传递形参,我们可以把“泛型”理解为数据类型的一个占位符(形式参数),即告诉编译器,在调用泛型时必须传入实际类型。
泛型<T,E,V>像一个占位符一样表示“未知的某个数据类型”,我们在真正调用的时候传入这个“数据类型”
泛型定义格式:
1.<类型>:指定一种类型的格式,这里的类型可以看成是形参
2.<类型1,类型2,......>:指定多种类型的格式,多种类型之间用逗号隔开,这里的类型可看作形参
3.将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型
package rongqi;
public class testgeneric {
public static void main(String[]args) {
mycollection<String> mc=new mycollection<String>();
mc.set("张三", 0);
String b=mc.get(0);
}
}
class mycollection<E>{
Object[] objs=new Object[5];
public void set(E e,int index) {
objs[index]=e;
}
public E get(int index) {
return (E)objs[index];
}
}
3.Collection接口
Collection表示一组对象、同时集中,收集的意思,Collection接口的两个子接口是List、Set接口。
JDK不实现此接口的任何直接实现,他提供更具体的子接口实现
创建Colection集合的对象的方式:
1.多态的方式
2.具体的实现类ArrayList
import java.util.*;
public class testlist {
public static void main(String[]args) {
Collection<String> c=new ArrayList<String>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
System.out.println(c);//[hello, world, java]
}
}
Collection集合常用的方法
方法名 | 说明 |
boolean add(E e) | 添加元素 |
boolean remove(Object o) | 从集合中移除指定的元素 |
void clear() | 清空集合中的元素 |
boolean contains(Object o) | 判断集合中是否存在指定的元素 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中元素的个数 |
import java.util.*;
public class testlist {
public static void main(String[]args) {
Collection<String> c=new ArrayList<String>();
//添加元素
System.out.println(c.add("hello"));//true
System.out.println(c.add("world"));//true
System.out.println(c.add("world"));//true
c.add("java");
System.out.println(c.remove("world"));
System.out.println(c.contains("javaee"));//判断集合中是否存在指定的元素
System.out.println(c.isEmpty());//判断集合是否为空
System.out.println(c.size());//集合的长度,集合中元素的个数
c.clear();//清空集合中的元素
System.out.println(c);
}
}
Collection集合的遍历
Iterator:迭代器,集合的专用遍历方式
Iterator<E>iterator():
1.返回集合中元素的迭代器,通过集合的iterator()方法得到
2.迭代器是通过集合的iterator()方法得到的,所以我们说他是依赖于集合而存在的
Iterator中的常用方法:
1.E next():返回迭代中的下一个元素
2.boolean hasNext():如果迭代具有更多元素,则返回true
import java.util.*;
public class testdome {
public static void main(String[]args) {
//创建集合对象
Collection<String> c=new ArrayList<String>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
Iterator<String> it=c.iterator();
// System.out.println(it.next());//hello
// System.out.println(it.next());//world
// System.out.println(it.next());//java
//System.out.println(it.next());//NoSuchElementException,被请求的元素不存在
while(it.hasNext()) {
//System.out.println(it.next());
String s=it.next();
System.out.println(s);
}
}
}
操作多个List
import java.util.ArrayList;
import java.util.Collection;
public class testlist {
public static void main(String[]args){
test01();
}
public static void test01(){
Collection<String> c=new ArrayList<>();
c.add("aa");
c.add("bb");
c.add("cc");
Collection<String> c1=new ArrayList<>();
c1.add("aa");
c1.add("dd");
c1.add("ee");
c.retainAll(c1);//取交集
System.out.println(c);//[aa]
c.addAll(c1);//添加
System.out.println(c);//[aa, aa, dd, ee]
c.removeAll(c1);//从c中移除于c1相同的
System.out.println(c);
}
}
List是有序、可重复的容器
有序:List中每个元素都有索引标记,可以根据元素的索引标记(在List中的位置)访问元素,从而精确的控制这些元素。
可重复:List允许加入重复的元素,更确切地讲,List通过允许满足e1.equals(e2)的元素重复加入容器。
常用的实现类:ArrayList、LinkedList、Vector
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class testlist {
public static void main(String[]args){
test02();
}
public static void test02(){
List<String> a=new ArrayList<>();
a.add("A");
a.add("B");
a.add("C");
a.add("D");
a.add(2,"你好");//[A, B, 你好, C, D]
System.out.println(a);
a.remove(2);//[A, B, C, D]
System.out.println(a);
a.set(2,"你好");//[A, B, 你好, D],直接覆盖原来的
System.out.println(a);
System.out.println(a.get(2));//你好,获取第二个索引位置
System.out.println(a.indexOf("BZ"));//返回不存在的,输出-1
System.out.println(a.indexOf("B"));//返回第一个B所在的索引位置
System.out.println(a.lastIndexOf("你好"));//返回最后出现的该字符的索引位置
}
}
4.Map接口
存储时使用键值对,键不能重复(如果重复,新的健将覆盖旧的键)
Map接口的实现类有HashMap、TreeTable、Properties
Map的方法
import java.util.HashMap;
import java.util.Map;
public class testmap {
public static void main(String[]args){
Map<Integer,String> m1=new HashMap<>();
m1.put(1,"one");
m1.put(2,"two");
m1.put(3,"three");
System.out.println(m1);//{1=one, 2=two, 3=three}
System.out.println(m1.get(1));//one
m1.remove(2);
System.out.println(m1);//{1=one, 3=three},移走
System.out.println(m1.containsKey(3));//检查是否包含键对象对应的键值对
System.out.println(m1.containsValue("two"));
System.out.println(m1.size());//包含键值对的数量
System.out.println(m1.isEmpty());//检查Map是否为空
m1.clear();//清空键值对
System.out.println(m1);
Map<Integer,String> m2=new HashMap<>();
m2.put(1,"one");
m2.put(2,"two");
m1.putAll(m2);//将m2的所有键值放到m1中
System.out.println(m1);
}
}
雇员信息
import java.util.HashMap;
import java.util.Map;
public class testmap2 {
public static void main(String[]args){
employee e1=new employee(1,"张三",10000);
employee e2=new employee(2,"李四",20000);
employee e3=new employee(3,"王五",30000);
Map<Integer,employee> m=new HashMap<>();
m.put(1,e1);
m.put(2,e2);
m.put(3,e3);
System.out.println(m);
}
}
class employee{
private int id;
private String ename;
private double salary;
public employee(int id,String ename,double salary){
this.id=id;
this.ename=ename;
this.salary=salary;
}
public String toString(){
return "id:"+id+" ename:"+ename+" salary:"+salary;
}
}
Map集合的遍历
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class testmap3 {
public static void main(String[]args){
Map<Integer,String> m=new HashMap<Integer,String>();
m.put(1,"张三");
m.put(2,"李四");
m.put(3,"王五");
System.out.println(m.get(1));//张三
Set<Integer> keyset=m.keySet();
System.out.println(keyset);//获取所有键的集合,[1, 2, 3]
for(Integer key:keyset){
System.out.println(key+","+m.get(key));
}
Set<Map.Entry<Integer,String>> entrySet=m.entrySet();
System.out.println(entrySet);//得到所有键值对的集合
for(Map.Entry<Integer,String>me:entrySet){
int key=me.getKey();
String value=me.getValue();
System.out.println(key+","+value);
}
}
}