国内外高校门户网站建设,jsp网站开发实例视频教程,宁德seo,企业网站管理系统怎么修改密码集合 我们接下来要学习的内容是Java基础中一个很重要的部分#xff1a;集合
1. Collection接口
1.1 前言
Java语言的java.util包中提供了一些集合类,这些集合类又称之为容器 提到容器不难想到数组,集合类与数组最主要的不同之处是,数组的长度是固定的,集合的长度是可变的集合
1. Collection接口
1.1 前言
Java语言的java.util包中提供了一些集合类,这些集合类又称之为容器 提到容器不难想到数组,集合类与数组最主要的不同之处是,数组的长度是固定的,集合的长度是可变的而数组的访问方式比较单一,插入/删除等操作比较繁琐,而集合的访问方式比较灵活 常用的集合类有List集合,Set集合,Map集合,其中List集合与Set集合继承了Collection接口,各个接口还提供了不同的实现类.
1.2 集合概念 集合的英文名称是Collection,是用来存放对象的数据结构,而且长度可变,可以存放不同类型的对象,并且还提供了一组操作成批对象的方法.Collection接口层次结构 中的根接口,接口不能直接使用,但是该接口提供了添加元素/删除元素/管理元素的父接口公共方法. 由于List接口与Set接口都继承了Collection接口,因此这些方法对于List集合和Set集合是通用的. 1.3 集合的继承结构 Collection接口 List 接口【数据有下标有序可重复】 ArrayList子类 LinkedList子类 Set 接口【数据无下标无序不可重复】 HashSet子类 Map 接口【键值对的方式存数据】 HashMap子类 1.4 Collection方法速查表 1.4.1 Collection接口测试
package cn.tedu.collection;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;/**本类用于测试Collection接口*/
public class TestCollection {public static void main(String[] args) {//1.创建Collection相关的对象//Collection c new Collection();//报错因为Collection是接口//Integer是泛型用来约束集合中的数据类型不能是基本类型必须是引用类型CollectionInteger c new ArrayList();//2.1测试集合中的常用方法--单个集合间的操作c.add(100);//向集合中添加元素 CtrlD快速向下复制c.add(200);//向集合中添加元素c.add(300);//向集合中添加元素c.add(400);//向集合中添加元素c.add(500);//向集合中添加元素System.out.println(c);//直接打印集合查看集合中的元素// c.clear();//清空当前集合中的所有元素
// System.out.println(c);System.out.println(c.hashCode());//获取集合对象的哈希码值System.out.println(c.toString());//打印集合的具体元素System.out.println(c.equals(200));//false,集合对象c与值200是否相等System.out.println(c.contains(200));//true,c集合中是否包含指定元素200System.out.println(c.isEmpty());//false判断集合是否为空System.out.println(c.remove(100));//true,移除集合中的指定元素成功返回trueSystem.out.println(c);//[200, 300, 400, 500]System.out.println(c.size());//4,返回集合的元素个数Object[] array c.toArray();//将指定的集合转为数组Object[]System.out.println(Arrays.toString(array));//[200, 300, 400, 500]//2.2测试多个集合间的操作CollectionInteger c2 new ArrayList();//创建第2个集合c2.add(2);//向c2集合添加元素c2.add(4);//向c2集合添加元素c2.add(5);//向c2集合添加元素System.out.println(c2);//查看c2集合中的元素c.addAll(c2);//把c2集合的所有元素添加到c集合当中System.out.println(c);//c2集合的所有元素追加到了c集合末尾System.out.println(c2);//c2集合本身没有任何改变//当前集合c是否包含指定集合c2中的所有元素System.out.println(c.containsAll(c2));System.out.println(c.contains(200));//c是否包含单个指定元素200System.out.println(c.removeAll(c2));//删除c集合中属于c2集合的所有元素System.out.println(c);System.out.println(c.add(5));System.out.println(c);System.out.println(c.retainAll(c2));//取c集合与c2集合的交集(公共元素)System.out.println(c);//[5]//3.迭代集合/遍历集合/**迭代步骤* 1.获取集合的迭代器 c.iterator();* 2.判断集合中是否有下一个可迭代的元素 it.hasNext()* 3.获取当前迭代到的元素 it.next()*/IteratorInteger it c.iterator();while(it.hasNext()){Integer num it.next();System.out.println(num);}}
}1.5 泛型
1.5.1 概述 我们可以观察一下下面的代码中有什么元素是我们之前没见过的呢? 其实就是 ? 的部分,它就是泛型 泛型是GenericsJDK1.5 的一个新特性通常用来和集合对象一起使用 泛型概念非常重要它是程序的增强器它是目前主流的开发方式
1.5.2 作用
那泛型有什么作用呢 我们可以把泛型理解成一个“语法糖”本质上就是编译器为了提供更好的可读性而提供的一种小手段小技巧虚拟机层面是不存在所谓“泛型”的概念的。是不有点神奇不知所云别着急等我讲完你就清楚了。
我们可以通过泛型的语法定义,来约束集合中元素的类型,编译器可以在编译期根据泛型约束提供一定的类型安全检查这样可以避免程序运行时才暴露BUG,代码的通用性也会更强 泛型可以提升程序代码的可读性,但是它只是一个“语法糖”(编译后这样的部分会被删除,不出现在最终的源码中),所以不会影响JVM后续运行时的性能.
1.5.3 泛型示例
示例1 : 我们创建一个ArrayList,看到eclipse发出黄线警告,这是为什么呢? 原因:ArrayList定义时使用了泛型,在声明时需要指定具体的类型 我们把这个””的方式称之为泛型,那么泛型有什么样的作用呢?就是在编译阶段检查传入的参数是否正确 有了泛型,我们可以看到要求存放的是String类型,而测试时存放的是int类型的100,所以编译器报错: 类型List的add方法要求添加的类型为String类型,int类型不匹配,不能正确存入
1.5.4 泛型声明
泛型可以在接口 类 方法上使用 在方法的返回值前声明了一个,表示后面出现的E是泛型,而不是普通的java变量
1.5.5 常用名称 1.5.6 泛型测试
1.泛型测试
package cn.tedu.generic;import java.util.ArrayList;
import java.util.List;/**本类用于测试泛型的优点*/
public class TestGeneric1 {public static void main(String[] args) {/**1.泛型是怎么来的?--想要模拟数组的数据类型检查*/String[] a new String[5];//创建一个用来存放String类型数据的数组,长度为5a[2] 泡泡;a[4] 涛涛;//数组的好处:在编译时期检查数据的类型,如果不是要求的类型会在编译器就报错//a[0] 1;//a[1] 8.8;//a[3] c;/**2.泛型通常会结合着集合一起使用*/List list new ArrayList();//注意导包:java.util...//没有泛型,数据类型根本没有约束 -- 太自由!!!list.add(江江);list.add(1);list.add(8.8);list.add(a);System.out.println(list);//通过打印查看集合中的元素/**3.引入泛型--主要目的是想通过泛型来约束集合中元素的类型?*//**4.泛型的好处:可以把报错的时机提前,在编译期就报错,而不是运行后抛出异常* 在向集合中添加元素时,会先检查元素的数据类型,不是要求的类型就编译失败* */ListString list2 new ArrayListString();//注意导包:java.util...list2.add(雷神);//约束了类型以后,只可以传String参数//list2.add(1);//list2.add(8.8);//list2.add(d);/**5.type--type的值应该如何写?* 需要查看要存放的数据类型是什么,根据类型进行定义* 但是type必须是引用类型,不是基本类型*///Listint list3 new ArrayListint();//注意导包:java.util...ListInteger list3 new ArrayListInteger();//注意导包:java.util...list3.add(100);list3.add(200);System.out.println(list3);}
}
2.泛型测试
package cn.tedu.generic;
/**本类用来测试泛型的优点2*/
public class TestGeneric2 {public static void main(String[] args) {//需求:打印指定数组中的所有元素Integer[] a {1,2,3,4,5,6,7,8,9,10};print(a);String[] b {大哥,二哥,三哥,四哥,五哥,六哥,小弟};print(b);Double[] c {6.0,6.6,6.66,6.666,6.6666};print(c);}/**1.泛型可以实现通用代码的编写,使用E表示元素的类型是Element类型 -- 可以理解成神似多态*//**2.泛型的语法要求:如果在方法上使用泛型,必须两处同时出现,一个是传入参数的类型,一个是返回值前的泛型类型,表示这是一个泛型*/private static E void print(E[] e) {for(E d :e) {System.out.println(d);}}// public static void print(Double[] c) {
// for(Double d : c) {
// System.out.println(d);
// }
// }
//
// public static void print(String[] b) {
// for(String s : b) {
// System.out.println(s);
// }
// }
//
// public static void print(Integer[] a) {
// //使用普通循环遍历数组比较复杂,引入高效for循环
// //普通循环的好处是可以控制循环的步长(怎么变化)
// for (int i 0; i a.length; ii2) {
// System.out.println(a[i]);
// }
// /**
// * 高效for/foreach循环--如果只是单纯的从头到尾的遍历,使用增强for循环
// * 好处:比普通的for循环写法简便,而且效率高
// * 坏处:没有办法按照下标来操作值,只能从头到尾依次遍历
// * 语法:for(1 2 : 3){代码块} 3是要遍历的数据 1是遍历后得到的数据的类型 2是遍历起的数据名
// */
// for(Integer i : a) {
// System.out.print(i);
// }
// }
} 补充高效for循环/foreach循环 高效for/foreach循环–如果只是单纯的从头到尾的遍历,使用增强for循环 好处:比普通的for循环写法简便,而且效率高 坏处:没有办法按照下标来操作值,只能从头到尾依次遍历 语法:for(1 2 : 3){代码块} 3是要遍历的数据 1是遍历后得到的数据的类型 2是遍历起的数据名 1.6 List接口
1.6.1 概述 有序的colletion(也称为序列).此接口的用户可以对列表中的每个元素的插入位置进行精确的控制,用户可以根据元素的整数索引(在列表中的位置)来访问元素,并搜索列表中的元素. 1.6.2 特点
元素都有下标数据是有序的允许存放重复的元素
1.6.3 List方法速查表 1.6.3.1 List接口测试
1
package cn.tedu.collection;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;/**本类用于测试List接口*/
public class TestList {public static void main(String[] args) {//1.创建List的多态对象注意List是接口不可实例化ListString list new ArrayListString();//2.测试继承自Collection中的方法list.add(大力娃);//向list集合中存入数据list.add(千顺娃);list.add(头铁娃);list.add(喷火娃);list.add(喷水娃);list.add(隐身娃);list.add(小紫娃);System.out.println(list);//查看集合中的元素// list.clear();//清空集合
// System.out.println(list);System.out.println(list.contains(喷火娃));//true,判断集合是否包含指定元素System.out.println(list.equals(喷水娃));//false,集合对象与String数据不等System.out.println(list.isEmpty());//false,判断集合是否为空System.out.println(list.remove(小紫娃));//移除集合中指定的元素System.out.println(list.size());//6获取集合中元素的个数System.out.println(Arrays.toString(list.toArray()));//将集合转成数组//3.测试List接口自己的方法--List有序可以根据索引来操作集合中的元素list.add(小蝴蝶);//追加在最后list.add(1,蛇精);//在指定的索引处添加元素list.add(3,小蝴蝶);//在指定的索引处添加元素System.out.println(list);System.out.println(list.indexOf(小蝴蝶));//3,获取指定元素第一次出现的索引System.out.println(list.lastIndexOf(小蝴蝶));//8获取指定元素最后一次出现的索引System.out.println(list);//根据索引删除元素并将被删除的元素返回System.out.println(list.remove(5));System.out.println(list);System.out.println(list.get(3));//获取指定索引处的元素System.out.println(list.set(7,蝎子精));//修改指定索引处元素的值为蝎子精System.out.println(list);//4.测试集合间的操作ListString list2 new ArrayList();//创建第2个集合list2.add(1);//向集合2中添加元素list2.add(2);list2.add(3);list2.add(4);System.out.println(list2);//查看集合中的元素//将2集合的所有元素添加到list集合中System.out.println(list.addAll(list2));//将2集合的所有元素添加到list集合的指定位置System.out.println(list.addAll(1,list2));System.out.println(list);//判断list集合中是否包含list2集合中的所有元素System.out.println(list.containsAll(list2));//移除list集合中属于list2集合中的所有元素System.out.println(list.removeAll(list2));System.out.println(list);}
}2
package cn.tedu.collection;import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;/**本类用于进一步测试List接口*/
public class TestList2 {public static void main(String[] args) {//1.创建List接口的多态对象ListString list new ArrayList();//2.向创建好list集合添加元素list.add(喜羊羊);list.add(美羊羊);list.add(懒羊羊);list.add(沸羊羊);list.add(小肥羊);list.add(肥羊卷);System.out.println(list);//3.测试集合的迭代/**集合的迭代方式* 1.for循环* 2.高效for循环* 3.iterator* 4.listIterator* *///方式一因为List集合是有序的元素有下标的所以可以根据下标进行遍历//从哪开始0 到哪结束list.size()-1 如何变化for(int i 0;ilist.size();i){//根据本轮循环遍历到的索引值获取对应的集合元素System.out.println(list.get(i));}System.out.println(************方式一*************);//方式二因为普通for循环遍历效率低语法复杂所以使用高效for来遍历//格式for(本轮遍历到的元素类型 元素名 要遍历的内容名){循环体}for( String s : list){System.out.println(s);}System.out.println(************方式二*************);//方式三从父接口中继承过来的迭代器iterator//1.获取对应的迭代器对象IteratorString it list.iterator();//2.通过刚刚获取到的迭代器循环迭代集合中的所有元素while(it.hasNext()){//判断是否仍有下一个元素可以迭代System.out.println(it.next());//打印当前获取到的元素}System.out.println(************方式三*************);/**方式四listIterator属于List接口特有的迭代器* IteratorE--父接口--hasNext() next()* ListIteratorE--子接口--除了父接口的功能以外* 还有自己的特有功能比如逆序遍历添加元素等等但是不常用* public interface ListIteratorEextends IteratorE* */ListIteratorString it2 list.listIterator();while(it2.hasNext()){System.out.println(it2.next());}System.out.println(list);System.out.println(listIterator的逆序遍历);ListIteratorString it3 list.listIterator();while(it3.hasNext()){//判断是否有下一个元素可迭代System.out.println(it3.next());//打印当前迭代到的元素if(!it3.hasNext()){//直到迭代器没有下一个元素可迭代--到最后了System.out.println(开始逆序迭代);while (it3.hasPrevious()){//判断是否有上一个元素可迭代System.out.println(it3.previous());//打印获取到的上一个元素}break;//终止循环不然会一直从头到尾再从尾到头迭代}}}
}1.6.3.2 ArrayList
1概述 存在java.util包中内部是用数组结构存放数据,封装数组的操作,每个对象都有下标内部数组默认的初始容量是10,如果不够会以1.5倍的容量增长查询快,增删数据效率会低 2创建对象 3测试
package cn.tedu.list;import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;/**本类用于ArrayList相关测试*/
public class TestArrayList {public static void main(String[] args) {//1.创建对应的集合对象/**底层会自动帮我们创建数组来存放对象并且数组的初始容量是10*/ArrayListInteger list new ArrayList();//2.向集合中添加元素用于测试list.add(100);list.add(200);list.add(300);list.add(400);list.add(400);list.add(300);System.out.println(list);//3.测试常用方法//list.clear();//清空集合//System.out.println(list);//[]//false,是否包含指定元素“100”这是String不是Integer,不包含System.out.println(list.contains(100));System.out.println(list.get(0));//100,根据下标获取元素System.out.println(list.indexOf(400));//3判断指定元素第一次出现的位置System.out.println(list.lastIndexOf(400));//4判断指定元素最后一次出现的位置System.out.println(list.remove(1));//200,移除指定位置处的元素//System.out.println(list.remove(300));/**上面的代码会报错数组下标越界index:300 size:5* 主要是因为List中有两个重载的remove(),如果传入的是300* 会认为是int类型的index索引所以如果想指定元素删除数据* 需要把int类型的300手动装箱成Integer类型*/System.out.println(list.remove(Integer.valueOf(300)));System.out.println(list.set(2,777));//修改指定索引处的元素的值为777System.out.println(list.size());//获取列表中元素的个数//4.进行集合的迭代//方式1for循环System.out.println(方式一for循环迭代);for(int i 0;i list.size()-1 ; i){System.out.println(list.get(i));}//方式2高效for循环System.out.println(方式二高效for循环迭代);//for(本轮遍历到元素的类型 元素名 要遍历的集合名){循环体}for(Integer t : list){System.out.println(t);}//方式3iterator迭代器System.out.println(方式三iterator迭代器);//获取迭代器对象IteratorInteger it list.iterator();//循环迭代集合中的所有元素while(it.hasNext()){//判断是否有下一个元素可迭代如果有继续循环System.out.println(it.next());//打印本轮迭代到的元素}//方式4listIteratorSystem.out.println(方式四list独有的迭代器listIterator);//获取迭代器对象ListIteratorInteger it2 list.listIterator();//循环迭代集合中的所有元素while(it2.hasNext()){//判断是否有下个元素可迭代System.out.println(it2.next());//打印本轮迭代到的元素}}
}1.6.3.3 LinkedList
1概述 链表,两端效率高,底层就是链表实现的 2创建对象 LinkedList() 构造一个空列表
3常用方法 1.void addFirst(E e) 添加首元素 2.void addLast(E e) 添加尾元素 3.E getFirst() 获取首元素 4.E getLast() 获取尾元素 5.E element() 获取首元素 6.E removeFirst() 删除首元素 7.E removeLast() 删除尾元素 1.boolean offer(E e) 添加尾元素 2.boolean offerFirst(E e) 添加首元素 3.boolean offerLast(E e) 添加尾元素 4.E peek() 获取首元素 5.E peekFirst() 获取首元素 6.E peekLast() 获取尾元素 7.E poll() 返回并移除头元素 8.E pollFirst() 返回并移除头元素 9.E pollLast() 返回并移除尾元素 4测试
package cn.tedu.colletion;import java.util.LinkedList;/**本类用于测试LinkedList的相关测试*/
public class TestLinkedList {public static void main(String[] args) {//1.创建对象LinkedListString list new LinkedList();//2.添加数据list.add(孙悟空);list.add(猪八戒);list.add(唐三藏);list.add(沙师弟);list.add(白龙马);System.out.println(list);//3.1自行测试从collection继承过来的共性方法测试//3.2 LinkedList特有方法测试list.addFirst(蜘蛛精);//添加首元素list.addLast(玉兔精);//添加尾元素System.out.println(list);System.out.println(list.getFirst());//获取首元素System.out.println(list.getLast());//获取尾元素System.out.println(list.removeFirst());//移除首元素,成功移除会返回移除的数据System.out.println(list);System.out.println(list.removeLast());//移除尾元素,成功移除会返回移除的数据System.out.println(list);//4.其他测试//4.1创建对象LinkedListString list2 new LinkedList();//4.2添加数据list2.add(水浒传);list2.add(三国演义);list2.add(西游记);list2.add(红楼梦);System.out.println(list2);System.out.println(list2.element());//获取但不移除此列表的首元素(第一个元素)/**别名:查询系列*/System.out.println(list2.peek());//获取但不移除此列表的首元素(第一个元素)System.out.println(list2.peekFirst());//获取但不移除此列表的首元素(第一个元素)System.out.println(list2.peekLast());//获取但不移除此列表的尾元素(最后一个元素)/**别名:新增系列*/System.out.println(list2.offer(遮天));//将指定元素添加到列表末尾System.out.println(list2.offerFirst(斗罗大陆));//将指定元素插入列表开头System.out.println(list2.offerLast(斗破苍穹));//将指定元素插入列表末尾System.out.println(list2);/**别名:移除系列*/System.out.println(list2.poll());//获取并且移除此列表的首元素(第一个元素),成功移除,返回移除元素System.out.println(list2.pollFirst());//获取并且移除此列表的首元素(第一个元素),成功移除,返回移除元素,如果此列表为空,则返回nullSystem.out.println(list2.pollLast());//获取并且移除此列表的尾元素(最后一个元素),成功移除,返回移除元素,如果此列表为空,则返回nullSystem.out.println(list2);}
}
1.7 拓展
1.7.1 ArrayList扩容
ArrayList相当于在没指定initialCapacity时就是会使用延迟分配对象数组空间当第一次插入元素时才分配10默认个对象空间。假如有20个数据需要添加那么会分别在第一次的时候将ArrayList的容量变为10之后扩容会按照1.5倍增长。也就是当添加第11个数据的时候Arraylist继续扩容变为10*1.515当添加第16个数据时继续扩容变为15 * 1.5 22个 ArrayList没有对外暴露其容量个数查看源码我们可以知道实际其值存放在elementData对象数组中那我们只需拿到这个数组的长度观察其值变化了几次就知道其扩容了多少次。怎么获取呢只能用反射技术了。
