当需要在java程序中记录多个类型不同的对象数据时，则准备一个集合。
集合的顶层框架是：java.util.Collection集合和java.util.Map集合
Collection存取元素单位是单个元素，Map是单对元素。
Collection包括List接口，Queue接口和Set接口。
List接口包括：ArrayList类,LinkedList类,Stack类,Vector类
Set接口包括: HashSet类,TreeSet类
boolean add(); 添加单个元素
boolean addAll(); 添加全部元素
boolean contains(); 判断是否包含指定对象
boolean containsAll(); 判断是否包含全部对象
boolean retainAll(); 保留当前集合中存在且参数集合中存在的所有对象
boolean remove(); 移除某个元素
boolean removeAll(); 移除指定的所有元素
void clear(); 清空集合
int size(); 返回包含对象的个数
boolean isEmpty(); 判断是否为空
boolean equals(); 判断是否相等
int hashCode(); 获取当前集合的哈希码值
Object[] toArray(); 将集合转为数组
Iterator iterator(); 获取当前集合的迭代器
public class Test1 {
public static void main(String[] args) {
// 创建一个ArrayList集合指向Collection父类型
Collection a1 = new ArrayList();
// 输出结果为 [] // 因为还没有往里面添加元素
System.out.println(a1);
// 输出一行线方便与下面的输出分隔开，方便观察
System.out.println("--------------------------------------");
// 添加单个元素
a1.add("wang");
System.out.println(a1);
a1.add(123);
System.out.println(a1);
a1.add("pikaqiu");
System.out.println(a1);
System.out.println("--------------------------------------");
// 创建一个ArrayList集合指向Collection父类型
Collection a2 = new ArrayList();
// 将a1中的所有元素添加到a2里
a2.addAll(a1);
System.out.println(a2);
}
}
public class Test2 {
public static void main(String[] args) {
// 创建一个ArrayList集合指向Collection父类型
Collection a1 = new ArrayList();
//往集合a1中添加一系列元素
a1.add(1);
a1.add(2);
a1.add("pikaqiu");
//判断a1中是否包含1,包含输出true，不包含输出false
System.out.println("a1包含元素1："+a1.contains(1));
//判断a1中是否包含5,包含输出true，不包含输出false
System.out.println("a1包含元素5："+a1.contains(5));
System.out.println("----------------------------------------");
// 创建一个ArrayList集合指向Collection父类型
Collection a2 = new ArrayList();
//往集合a2中添加一系列元素
a2.add(1);
a2.add(2);
// 判断集合a1是否包含集合a2
System.out.println("a1包含集合a2："+a1.containsAll(a2));
// 判断集合a2是否包含集合a1
System.out.println("a2包含集合a1："+a2.containsAll(a1));
System.out.println("----------------------------------------");
System.out.println("一开始的a1："+a1);
// 判断a1和a2都含有的对象并保留在a1中
System.out.println(a1.retainAll(a2));
System.out.println("后来的a1："+a1);
}
}
public class Test3 {
public static void main(String[] args) {
// 创建一个ArrayList集合指向Collection父类型
Collection a1 = new ArrayList();
//往集合a1中添加一系列元素
a1.add(1);
a1.add(2);
a1.add("pikaqiu");
System.out.println("一开始的a1:"+a1);
//移除a1中的元素1，移除成功输出移除元素成功，失败了输出移除元素失败
System.out.println(a1.remove(1)?"移除元素成功":"移除元素失败");
System.out.println("移除元素后的a1："+a1);
System.out.println("-------------------------------------------------");
// 创建一个ArrayList集合指向Collection父类型
Collection a2 = new ArrayList();
//往集合a1中添加一系列元素
a2.add(1);
a2.add(2);
a2.add(3);
a2.add(4);
a2.add(5);
a2.add("pikaqiu");
a2.add("pikaqiu1");
a2.add("wangwenxiao");
System.out.println("一开始的a2"+a2);
// 在a2中移除掉所有a1元素，移除成功输出移除元素成功，失败了输出移除元素失败
System.out.println(a2.removeAll(a1)?"移除元素成功":"移除元素失败");
System.out.println("移除元素后的a1："+a1);
System.out.println("-------------------------------------------------");
// 往a1里添加一些元素进行此处的判断
a1.add(1);
a1.add(2);
a1.add("pikaqiu");
// 输出未清空集合前的a1
System.out.println("一开始的a1"+a1);
//清空集合a1
a1.clear();
// 输出清空集合后的a1
System.out.println("清空集合后的a1："+a1);
// 判断集合a1是否为空
System.out.println("集合a1是否为空："+a1.isEmpty());
// 判断集合a2是否为空
System.out.println("集合a2是否为空："+a2.isEmpty());
System.out.println("-------------------------------------------------");
}
}
public class Test4 {
public static void main(String[] args) {
// 创建一个ArrayList集合指向Collection父类型
Collection a1 = new ArrayList();
//往集合a1中添加一系列元素
a1.add(1);
a1.add(2);
a1.add(3);
a1.add(4);
a1.add(5);
a1.add("pikaqiu");
a1.add("pikaqiu1");
a1.add("wangwenxiao");
//将集合转为数组
Object[] objects=a1.toArray();
//打印数组中所有元素
System.out.println("数组中元素："+ Arrays.toString(objects));
System.out.println("-------------------------------------------");
//将数组转为集合
Collection objects1=Arrays.asList(objects);
//打印集合中的所有蒜素
System.out.println("集合中元素："+objects1);
System.out.println("-------------------------------------------");
}
}
迭代器是什么：迭代器是用于遍历集合中的元素的一种方式
boolean hasNext(); 判断集合中是否有可以访问的元素
E next(); 用于取出一个元素并且指向下一个元素
void remove(); 用于删除访问到的最后一个元素
public class Test6 {
public static void main(String[] args) {
// 创建一个ArrayList集合指向Collection父类型
Collection a1 = new ArrayList();
//往集合a1中添加一系列元素
a1.add(1);
a1.add(2);
a1.add(3);
a1.add("pikaqiu1");
a1.add("pikaqiu2");
a1.add("pakaqiu3");
System.out.println("该集合为："+a1);
// 创建该集合的一个迭代器
Iterator iterator = a1.iterator();
// 利用while循环依次输出集合内数据
// 注意 interator.hasNext() 是用来判断当前集合是否还有数据可供输出，该方法返回一个boolean值类型
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("-----------------------------------");
System.out.println("利用迭代器遍历进行字符串拼接输出集合样式");
System.out.println("此处需要再创建一个迭代器,上面的迭代器已然结束");
// 创建一个该集合的迭代器
Iterator iterator1=a1.iterator();
StringBuilder sb=new StringBuilder();
sb.append("[");
while(iterator1.hasNext()){
Object o=iterator1.next();
if(iterator1.hasNext()) {
sb.append(o).append(",").append(" ");
}else {
sb.append(o).append("]");
}
System.out.println(sb);
}
}
}
public class Test7 {
public static void main(String[] args) {
//创建一个ArrayList集合指向Collection父类型
Collection a1 = new ArrayList();
//往集合a1中添加一系列元素
a1.add(1);
a1.add(2);
a1.add(3);
a1.add(4);
a1.add(5);
a1.add("pikaqiu");
a1.add("pikaqiu1");
a1.add("wangwenxiao");
//for each 遍历集合并输出数据
for(Object o:a1){
System.out.println(o);
}
}
}
List的实现类主要有ArrayList，LinkedList，Stack ……
ArrayList： 底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。
LinkedList： 底层是采用双向链表进行数据管理的，访问不方便，但是增删元素方便
Stack：栈，先进后出，后进先出
void add(int index,E element) 向集合中指定位置添加元素
boolean addAll(int index,Collection<?extends E>c) 向集合中添加所有元素
E get(int index) 从集合中获取指定位置的元素
int indexOf(Object o) 查找参数指定的对象是否存在，存在则返回对象所在下标，不存在返回-1
int lastIndexOf(Object o) 反向查找参数指定的对象是否存在，存在则返回对象所在下标，不存在返回-1
E set(int index,E element) 修改指定位置的元素
E remove(int index) 删除指定位置的元素
List subList(int fromIndex,int toIndex) 用于获取子List
public class Test1 {
public static void main(String[] args) {
// 创建一个list集合对象LinkedList指向父类型List
// 由于此处要进行List集合的增加操作，而list实现类里LinkedList类方便增删操作，所以利用LinkedList实现类
List list1 = new LinkedList();
// 向集合中添加元素,可以指定下标也可以不指定下标
// 如果不指定下标则依次增加，如果指定下标则按照下标进行添加
list1.add(0,1);
list1.add(1,"wang");
list1.add(2,666);
System.out.println("一开始的list1集合："+list1);
System.out.println("在下标1处添加元素222，那么此处往后的元素会依次后移");
list1.add(1,222);
System.out.println("在下标为1处添加元素222后的list1集合："+list1);
System.out.println("---------------------------------------------------------");
// 创建一个list集合对象LinkedList指向父类型List
// 由于此处要进行List集合的增加操作，而list实现类里LinkedList类方便增删操作，所以利用LinkedList实现类
List list2 = new LinkedList();
// 向集合中添加元素,可以指定下标也可以不指定下标
// 如果不指定下标则依次增加，如果指定下标则按照下标进行添加
list2.add(0,111111);
list2.add(1,"wang11111111");
list2.add(2,66611111);
System.out.println("集合list2："+list2);
System.out.println("在集合list1下标3处增加list2所有元素，那么此处往后的下标会依次后移");
list1.addAll(3,list2);
System.out.println("在集合list1下标3处增加list2所有元素后的list1:"+list1);
System.out.println("---------------------------------------------------------");
}
}
public class Test2 {
public static void main(String[] args) {
// 创建一个list集合对象ArrayList指向父类型List
// 由于此处要进行List集合的增加操作，而list实现类里ArrayList类支持下标访问，所以利用ArrayList实现类
List list1 = new ArrayList();
// 向集合中添加元素,可以指定下标也可以不指定下标
// 如果不指定下标则依次增加，如果指定下标则按照下标进行添加
// 向集合中添加一系列元素
list1.add(0,1);
list1.add(1,"wang");
list1.add(2,666);
list1.add(3,1111);
list1.add(4,"pi");
list1.add(5,777);
System.out.println("list1集合为："+list1);
// 访问下标为3的元素
System.out.println("下标为3的元素是："+list1.get(3));
System.out.println("---------------------------------------");
System.out.println("查看集合list中是否存在666元素，存在返回元素所在下标位置");
System.out.println(list1.indexOf(666));
System.out.println("查看集合list中是否存在66元素，不存在返回-1");
System.out.println(list1.indexOf(66));
}
}
public class Test3 {
public static void main(String[] args) {
//定义一个list集合
List list1 = new ArrayList();
// 向集合中添加一系列元素
list1.add(0,1);
list1.add(1,"wang");
list1.add(2,666);
list1.add(3,1111);
list1.add(4,"pi");
list1.add(5,777);
System.out.println("一开始的list1集合为："+list1);
System.out.println("---------------------------------------------");
// 获取修改数据
Scanner s=new Scanner(System.in);
System.out.print("请输入要修改元素的下标：");
int index=s.nextInt();
// 判断所修改数据是否存在
if(index<list1.size()) {
System.out.print("指定元素存在，请输入修改值：");
String value=s.next();
// 对list集合进行修改操作
list1.set(index,value);
System.out.println("被修改后的list1集合为："+list1);
}else {
System.out.print("指定元素不存在，修改进程结束！");
}
System.out.println("---------------------------------------------");
}
}
public class Test4 {
public static void main(String[] args) {
//定义一个list集合
List list1 = new ArrayList();
// 向集合中添加一系列元素
list1.add(0,1);
list1.add(1,"wang");
list1.add(2,666);
list1.add(3,1111);
list1.add(4,"pi");
list1.add(5,777);
System.out.println("一开始的list1集合为："+list1);
System.out.println("-------------------------------------------------------");
// 获取删除元素数据
Scanner s=new Scanner(System.in);
System.out.print("请输入要删除元素的下标：");
int index=s.nextInt();
// 对集合进行删除操作
if(index<list1.size()) {
System.out.println("指定删除元素存在，删除成功！");
list1.remove(index);
}else {
System.out.println("指定元素不存在，删除失败！");
}
System.out.println("删除元素后的集合为："+list1);
System.out.println("-------------------------------------------------------");
// 获取删除元素数据
System.out.print("请输入要删除元素的值：");
String value=s.next();
// 对集合进行删除操作
list1.remove(value);
System.out.println("删除元素后的集合为："+list1);
System.out.println("-------------------------------------------------------");
}
}
public class Test5 {
public static void main(String[] args) {
// new一个stack
Stack stack = new Stack();
// 对栈元素依次入栈并打印
for(int i=1;i<10;i++){
stack.push(i*3);
System.out.println("第"+i+"个入栈的数据是："+(i*3));
}
System.out.println("stack= "+stack);
System.out.println("--------------------------------------------");
// 查看栈顶元素并打印
System.out.println("stack中栈顶元素是："+stack.peek());
System.out.println("--------------------------------------------");
// 对栈中元素依次出栈并打印
int size=stack.size();
for(int i=1;i<=size;i++){
// 得到出栈元素
Object o= stack.pop();
System.out.println("第"+i+"个出栈的数据是："+o);
}
System.out.println("---------------------------------------------");
}
}
? 先进先出， 实现类主要有LinkedList类
boolean offer(E e); 将一个对象添加至队尾，若添加成功则返回true
E poll(); 从队首返回并删除一个元素
E peek(); 返回队首的元素，但并不删除
public class Test1 {
public static void main(String[] args) {
// 创建一个对象
Queue queue1 = new LinkedList();
// 添加元素
queue1.offer(1);
queue1.offer(2);
queue1.offer(3);
// 打印出集合
System.out.println("queue1= "+queue1);
System.out.println("-----------------------------------------------");
int size=queue1.size();
for(int i=1;i<=size;i++){
System.out.println(queue1.poll()+"删除成功");
System.out.println("删除后的queue1："+queue1);
}
}
}
public class Person<T> {
private String name;
private int age;
private T high;
public Person() {
super();
}
public Person(String name, int age, T high) {
this.name = name;
this.age = age;
this.high = high;
}
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;
}
public T getHigh() {
return high;
}
public void setHigh(T high) {
this.high = high;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", high=" + high +
'}';
}
}
public class PersonTest {
public static void main(String[] args) {
Person<String> p=new Person<>();
p.setHigh("111");
System.out.println(p);
}
}
输出：Person{name='null', age=0, high=111}
输出结果对应的是Person类中的toString方法
// person类中的泛型在继承的时候都是没有保留的
1. public class SubPerson extends Person { //丢弃泛型并且没有指定类型，默认为Object类型 }
2. public class SubPerson extends Person<String> { //丢弃泛型但是指定了泛型类型 }
语法格式：
[访问权限] <泛型> 返回值类型 方法名[泛型标识 参数名称]{ 方法体； }
例如：
public <E> void t[E e]{}
<?> 无限制通配符:表示我们可以传入任意类型的参数
<? extends E> 类型的上界是E，只能是E或者E的子类
<? super E> 类型的下界是E，只能是E或者E的父类
Set集合不分进入次序
Set数据不允许重复，list的数据允许重复
Set集合的实现类主要有HashSet（底层是哈希表进行数据管理的）
和TreeSet（底层是红黑树进行数据管理的）
（HashSet的底层是Map集合
有序二叉树（是特殊的二叉树）：左子节点<根节点<右子节点
红黑树数特殊的有序二叉树 ）
public class Test1 {
public static void main(String[] args) {
HashSet<String> s = new HashSet<>();
System.out.println(s);
s.add("wang");
System.out.println(s);
s.add("wen");
System.out.println(s);
s.add("xiao");
System.out.println(s);
System.out.println("--------------------");
System.out.println("验证元素不能重复：");
System.out.println(s.add("wang")?"元素插入成功":"元素重复，插入失败");
}
}
（三）TreeSet
实现自然排序
public int compareTo( ){
// return 0; //调用对象和参数对象相等
// return -1; //调用对象小于参数对象
// return 1; // 调用对象大于参数对象
}
实现比较器排序
Comparator<类型> c=new Comparator<类型>(){
public int compare(类型 n1,类型 n2){
//n1是新增对象，n2是已有对象
return n1.getAge()-n2.getAge(); // 按照年龄排序
}
}
（一）Map集合概述
Map<K,V> K:Key,相当于目录 V：Value，值
Key是不允许重复的，该列相当于collection
Key和Value都是String类型的
Map集合的主要实现类： HashMap类，TreeMap类，Hashtable类
（二)Map集合常用方法
V put(K Key,V value) 将该对数据存入Map，如果集合中中已经包含Key，那么替换Key
所对应的Value，返回值为该Key来源的Value，若没有则返回null
V get(Object Key) 返回与参数Key所对应的Value对象，如果不存在则返回null
boolean containKey(Object Key) 判断集合中是否包含指定的Key
boolean containValue(Object Value) 判断集合中是否包含指定的KeyValue
V remove(Object Key) 根据参数指定的key进行删除
Set<k> KeySet() 返回此映射中包含的键的Set视图
Collection<V> values() 返回此映射总包含的值的Set视图
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射的Set视图
先看效果 通过此项目可以学习到 Container、AnimatedSwitcher、FadeTransition、...
Ajax内部交流文档一、使用Ajax的主要原因 1、通过适当的Ajax应用达到更好的用户...
tomcat 的配置文件 server.xml里面找到: 复制代码 代码如下: Connector port="80...
? ? 老猿Python博文目录https://blog.csdn.net/LaoYuanPython ? 一、背景和需求 ...
LVM 是一个逻辑卷管理工具，包括分配磁盘、条带化、镜像和调整逻辑卷的大...
301跳转通常用在网站换域名和为了保持链接统一性所用的。比如你原来的域名 www.a...
1月13日消息 今日，微软 Edge 浏览器 Mac 预览版发布 89.0.760.0 版本更新，本次...
最近在开始把Oracle数据库的脚本转换成shell脚本，所以今天开始分享一下Oracle常...
Spring Security缓存的应用之登陆后跳转到登录前源地址 什么意思？ 用户访问网站...
1. 进入后台，风格界面模板总管理，page_login,template.html(13) TR TDclass=ta...
