一、选择排序
1.1选择排序的思想
使用数组中的第一个元素依次和后面的元素是比较，第一次比较完毕，最小值出现在最小索引处
依次这样比较，可以得到一个排好序的数组！1.2选择排序过程以及规律
使用0角标对应的元素依次和后面的元素是比较，第一次比较完毕，最小值出现在最小索引处！
比较的次数：数组长度-1次1.3选择排序核心代码实现
for(int i = 0;i<arr.length-1;i++){
for(int x = i+1 ;x<arr.length;x++){
if(arr[x]<arr[i]){
int temp = arr[i];
arr[i] = arr[x];
arr[x] = temp;
}
}
}二、常用类
2.1Object类的常用方法
2.1.1 getClass（）方法
获取正在运行的类（返回字节码文件对象）-----跟反射相关2.1.2 在java中获取一个类的字节码文件对象的方式有几种？
有三种
第一种：public final Class getClass(): 获取正在运行的类; (返回字节码文件对象)
第二种：在java中任意类型的class属性 Class s = 类名.class
第三种：Class
跟反射相关-提供静态功能--->返回值是它自己本身
public static Class forName(String classPathName);
这个方法在使用过程中，可能出现类找不到异常，谁调用这个方法谁处理这个异常，----给上面抛
这个方法的参数需要传递当前类的“全限定名称”2.1.3 toString()
public String toString()
返回的是一个字符串类型的数据 ------ 返回结果应该是简明扼要的，便于阅读的，建议子类覆盖此方法
直接输出对象名等价于----Object类的toString()
任何类都继承Object类---toString方法源码
* public String toString() {
* return getClass().getName() + "@" + Integer.toHexString(hashCode());
*
* //return this.getClass().getName() +"@" +Integer.Integer.toHexString(this.hashCode())
* }
*/
Integer.toHexString(整数类型):将整数类型---转成十六进制数据,并且以字符串形式体现2.1.4 hashCode()
public int hashCode():返回对象的哈希码值,不同的对象,它的哈希码值不同
* (理解为 "地址值",它不是实际意义的地址值----通过哈希算法算出来的)
*/2.1.5 ==和equals的区别（面试题）
==连接的是两个基本数据类型：比较的是两个数据值是否相等
==连接的两个是引用型数据类型，比较的是应用类型的地址值是否相等！
字符串常量相加:
* 先相加,然后看结果,是否在常量池中,如果有,直接返回值地址;否则开空间
* 字符变量相加:
* 先在常量池开辟空间,然后在操作;
*2.1.6 equals()
equals:Object的equaels方法默认比较的是两个对象的地址值相同,子类重写了equals(),就比较两个对象的内容是否相同
* 如果你要比较成员信息的内容是否相同,必须重写Object的equals方法以及hashCode,重写之后比较的是内容是否相同(成员信息)
* equals重写之后,是比较里面的每一个成员信息是否一样,如果都一样;
* 还有比较两个成员对应的hashCode是否一样,如果一样,是同一个人!2.1.7 clone()
Object的克隆方法：创建并返回此对象的”副本“-----前提必须实现Cloneable这个接口，否则无法克隆!protected Object clone() throws CloneNotSupportedException
这个类必须实现Cloneable这个接口，才可以克隆
* 如果一个接口没有成员变量,连成员方法都没有,将这类接口称为"标记接口"
* Cloneable接口:某个类如果能够实现这个接口,那么这个类对象就可以克隆!2.1.8 finalize()
Object类的垃圾回收方法
* protected void finalize()throws Throwable--跟gc垃圾回收器有关系
* 当jvm开启垃圾回收器的时候,就会回收堆内存中没有更多引用的对象(new 出来的东西)
*
* 当前垃圾回收器开始运行,会调用Object类的finalize()方法,来回收对象,子类重写了,会调用子类的finalize方法
*
System类--->public static void gc()运行垃圾回收器
// 手动开启垃圾回收器 (java语言中自动回收)---jvm垃圾回收--是一个线程(垃圾回收线程)2.2 Scanner
java.util.Scanner 文本扫描器（键盘录入数据的）
构造方法
public Scanner （InputStream source）:
创建一个文本扫描器，里面参数是字节输入流，读取键盘录入的一些数据
成员方法
获取功能:除过不能录入char类型之外.都可以录入!
int nextInt():录入int类型
String next() :录入字符串
String nextLine():录入一行字符串
InputMismatchException:录入数据与提供数据类型不匹配
判断功能
boolean hasxxx()：判断下一个录入的是为XXX类型
细节：如果先录入int，在录入String（使用String nextLine()）-----String的值可能会被漏掉
解决方案：
1)使用String next():录入单个字符串（推荐）
2）在使用nextLine()之前，重新创建一个新的Scanner对象；
//创建键盘录入对象
//Scanner sc = new Scanner(System.in) ;
//等价于
//System类---提供静态变量:in--而且是一个常量2.3 String类
代表字符串，是一个常量，创建之后，其值不能更改！
举例：
String s = "abc"; 开发中，定义字符串就是这个格式
字符串的底层就是一个字符数组组成 char data[] = {'a','b','c'} String s = new String(data);
构造方法：
public String():创建字符串对象
public String(String original):将指定的字符串传进去，构造一个字符串对象
public String(char[] Value):将字符串数组----构造成String
public String(char[] value,int offset,int count):将一部分字符数组转换成String
public String(byte[] bytes)将字节数组---构造成String
public String(byte[] bytes, int offset,int length):将一部分字节数组---构造成String
如果存在类型转换问题:
* 已知char[]--->String public String(char[] value)
* 已知byte[]--->String public String(byte[] bytes)
*
* 如果仅仅表示定义一个String对象---推荐的格式
* String 变量名 = "字符串常量" ;
byte[] bytes = {97,98,99,100,101} ;
String s5 = new String(bytes) ;//转换过程,将每一个数据找ASII码表对应的字符值,构造成字符串
System.out.println("s5:"+s5) ;//abcde2.3.1 面试题:s1和s2区别
String s1 = "hello";
String s2 = new String("hello");
第一个格式:
* 创建一个对象,直接在常量池中创建;
* 第二个格式:
* 需要在堆内存开辟空间,而且指向常量池地址:内存创建了两个对象!
*
* 两个都是创建字符串实例,但是推荐第一种,从内存角度考虑,消耗内存资源不严重!
2.3.2字符串常量相加
看代码写结果
Strings1="hello";
Strings2="world";
Strings3="helloworld";
System.out.println((s1+s2)==s3);
System.out.println((s1+s2).equals(s3));
System.out.println("hello"+"world"==s3);
System.out.println("helloworld"==s3);
System.out.println(("hello"+"world").equals(s3));
false
true
true
true
true字符串常量相加:
* 先相加,然后看结果,是否在常量池中,如果有,直接返回值地址;否则开空间
* 字符变量相加:
* 先在常量池开辟空间,然后在操作;2.3.3String类中常用的获取功能
1）public char charAt(int index) 获取指定索引值的对应的字符
2）public int length():字符串特有功能：获取字符串长度
//charAt(int index)+length()可以遍历字符串
for(int x = 0 ; x < s.length(); x++){
char ch = s.charAt(x) ;//获取指定索引值对应的字符
System.out.print(ch+"\t");
}
System.out.println();
3)public String concat(String str):拼接功能 将指定的字符串拼接到该字符串末尾,获取新的字符串
4)public int indexOf(String str)返回指定字符串第一次出现索引值
5）public int lastIndexOf(String str):返回指定子字符串最后一次出现的索引值
5)public String spilt(String regex):字符串拆分功能
6）public String substring (int beginIndex, int endIndex)
指定位置开始，截取到endIndex-1处结束，包前不包后
public String substring(int beginIndex)
指定位置开始，默认截取到末尾
2.3.4String 类中常见的转换功能
public byte[] getBytes():将字符串转换成字节数组（编码过程：将能看懂的东西----变成看不懂的）
一般不带参，使用idea默认的字符集（带参就按带参的，比如GBK是一个中文两个字节）
//idea设置的平台字符集：utf-8：一个中文三个字节
String(byte[] byte)；解码---->将看不懂的转为能看懂的字符串2.3.5 将字符串转换成字符数组
public char[] toCharArray 将字符串转换成字符数组
public static String Valueof(常见的基本类型/long/double/boolean/Object)
String万能方法：将上面的常用类型---转换成String
public String toUpperCase():将指定字符串转换成大写
public String toLowerCase():将指定字符串转换成小写2.3.6String 类的其他功能
String类判断功能以及其他功能:
* public boolean constains(String str):判断大串中是否包指定的子字符串
* public boolean equals(Object anObject)):比较两个字符串内容是否相同
* public boolean equalsIgnoreCase(String anotherString)):忽略大小写比较
* public boolean startsWith(String prefix):字符串是否以指定的前缀开头
* public boolean endsWith(String str):字符串是否以指定的后缀结尾
*
* 其他功能:
* public String replace(char oldChar,char newChar)替换功能:使用指定的新的字符替换以前的字符
* public String trim():删除前后两端空格
*
* 应用场景:trim(): 使用io(intput输入 Output输出)流进行 读写复制(文件内容在网络中传输)
* 文件内容前后有一些空字符出现,获取到文件内容之后,先去trim()去除两端空格2.4 StringBuffer
:字符串缓冲区，线程安全，支持可变的字符序列
什么叫线程安全------>后面讲的多线程
线程安全---->意味着“同步”---->执行效率低-----“银行类的网站”
线程不安全---->意味着“不同步”---->执行效率高-----“论坛的网站”----不安全----锁机制---来解决线程安全问题（多线程）
2.4.1 StringBuffer和StringBuilder
这两个类都是字符串缓冲区，都支持可变的字符序列
前者：使用在多线程环境里面，能够保证线程安全---意味着同步----执行效率低
后者：是StringBuffer的简易替换，使用在单线程环境中，线程不安全---不同步--执行效率高！
单线程使用StringBuilder:效率高（速度块）
构造方法：
public StringBuffer():无参构造方法，里面空的字符串序列，初始容量16个字符
public StringBuffer(String str):有参构造方法，将字符串构造为StringBuffer类型，容量大小：当前里面的字符串长度+16
前两个构造方法使用居多！
public StringBuffer(int capacity)：创建一个字符串，指定容量大小
1）获取字符串缓冲区长度---int length()
2)获取字符串缓冲区的容量-----int capacity()2.4.2 StringBuffer的添加删除的功能
添加：
§ public StringBuffer append(java任意类型数据)：可以将任意类型的元素添加（在末尾追加）到字符串缓冲区中，返回值是字符串缓冲区本身
§ public StringBuffer insert(int offset, 任意java数据类型)：在指定位置处的序列前面插入新的序列
§ public StringBuffer delete(int start,int end)从指定位置start处开始到end-1处的字符序列删除，返回值字符串缓冲区本身
§ public StringBuffer deleteCharAt(int index)在指定位置处删除指定的字符，返回字符缓冲区本身
§
§ 开发中使用居多:追加功能以及删除 deletCharAt(int index)使用居多
2.4.3 String<---->StringBuffer相互转换 (重点)
String----->StringBuffer
//方式1)可以通过StringBuffer的有参构造方法
//StringBuffer(String str)
//创建一个字符串缓冲
StringBuffer sb = new StringBuffer(s) ;
System.out.println(sb) ;
//方式2:通过StringBuffer的无参构造方法+append(String str)
StringBuffer sb2 = new StringBuffer() ;
sb2.append(s) ;
System.out.println(sb2);
StringBuffer------>String
方式1：
public String toString()返回字符串
StringBuffer sb = new StringBuffer();
String str = sb.toString();
//方式2:String类的构造方法
//public String(StringBuffer buffer)
String str2 = new String(buffer) ;
System.out.println(str2) ;2.4.4 StringBuffer的特有功能
§ public StringBuffer reverse()：字符串缓冲区反转功能，将字符串缓冲区中所有的字符序列反转！
需求:
* 键盘录入一个字符串,将字符串反转
*
* 方式1:不让你使用StringBuffer的特有功能,让你使用String
* 1)将录入的字符串---->转换成字符数组
* 2)定义一个String s = "" ;
* 3)将字符数组倒着遍历
* for(int i = 字符数组.length-1;i>0 ;i --){
* s += 字符数组[i] ;
*
* }
* 4)返回结果变量s
*/
//方式2:使用StringBuffer的反转功能
public static String reverse2(String s){
/*StringBuffer sb = new StringBuffer() ;
sb.append(s) ;
return sb.reverse().toString() ;*/
2.4.5 StringBuffer其他功能
public StringBuffer replace(int start,int end,String str)
* 使用指定的字符串str从指定位置开始到end-1处进行替换,返回该字符串缓冲区本身
* public String substring(int start):从指定位置开始截取,默认截取到末尾,返回被截取后的字符串
* public String substring(int start,int end):从指定位置开始截取到指定位置end-1处,返回被截取后的字符串2.5 Integer类
jdk提供了一个类Integer类,提供了一些功能:十进制转换成对应的进制的方法(静态方法)
四类八种的基本数据类型都会自动提升 对应的引用类型 jdk5以后新特性:自动拆装箱
*
* 拆箱:
* 这些包装类类型--->降为 基本类型
* 装箱:
* 就是基本类型--->提升 对应的引用类型
*
* 基本类型 引用类型的默认值null
* byte Byte
* short Short
* int Integer(特殊)
* long Long
*
* float Float
* double Double
*
* char Character(特殊)
*
* boolean Boolean
*
* 这些四类八种中的基本数据类型可以String进行相互转换的---->中间桥梁 ---->对应的基本类型的包装类类型!
* String-->Integer--->int
* "100" --->100
2.5.1 Integer类的构造方法
public Integer(int value):创建一个Integer实例,里面包含的int类型的值
* public Integer(String s) throws NumberFormatException: 将数字字符串转换成Integer的实例
* 可能会出现数字格式化异常(字符串如果不是数字字符串,就会出现这个异常)2.5.2 Integer特点
将int类型赋值给Integer变量 这种格式,执行底层方式valueOf(int i)
*
*
* public static Integer valueOf(int i) {
* 如果i的值在-128~127之间,直接从内部类--->IntegerCache缓存去中取数据
* if (i >= IntegerCache.low && i <= IntegerCache.high)
* return IntegerCache.cache[i + (-IntegerCache.low)]; // cache属性:Integer cache[] 长度 =i+128
* return new Integer(i); //如果上if不成立,重新开辟新的空间创建Integer实例
* }2.6 Character类
构造方法：
public Character（char value）:包含char类型的值
成员方法：
判断功能
public static boolean isDigit(char ch):判断当前字符是否为数字
public static boolean isLowerCase(char ch):判断当前字符是否为小写
public static boolean isUpperCase(char ch):判断当前字符是否为大写2.7 int基本类型和引用String的相互转换
String---int: int 变量名 = Integer.parseInt(已知的数字字符串) 推荐
* int---->String: Integer类提供静态方法 String 变量名 = Integer.toString(int类型的值)
*/
//方式1)比较简单
int i = 100 ;
String s = "" ;
s += i ; //拼接符号 s = s+i
System.out.println(s) ;//"100"
//推荐一步执行:
//Integer类提供了静态方法
//public static int parseInt(String s)throws NumberFormatException:要转的字符串必须为数字字符串
//万能方法:String--->long --->Long引用提供静态方法 public static long pasreLong(String str)三、其他类
3.1 System类
/**
* java.lang.System:不能实例化:提供了静态字段(静态变量)
* public static final PrintStream out :标准 打印输出流
* public static final PrintStream err 标准错误输出流
* public static final InputStream in 标准输入流
*/
/**
* System类常用的成员方法:
*
* public static long currentTimeMillis() 计算当前系统时间毫秒值 (很少单独用)
* 用来计算当前某个程序的时间复杂度(运行效率)
*
* public static void gc() 收到开启垃圾回收器 ---会调用finalize(),回收没有更多引用的对象
* public static void exit(int status): 参数为0:终止jvm
* public static void arraycopy(
* Object src, //原对象
* int srcPos, //原对象中的某个位置
* Object dest, //目标对象
* int destPos, //目标对象的某个位置
* int length) //指定的长度
*/
3.2 Randrom类
/**
* java.util.Random:伪随机数生成器 可以产生随机数 比Math.random()麻烦
* 两个构造方法:
* public Random() :无参构造方法(推荐)
* public Random(long seed):有参构造,创建一个指定long类型的变量的随机数生成器
* 两个成员方法:
* public int nextInt(): 产生伪随机数在,取值是int类型 的范围内
* public int nextInt(int n):产生0-n之间的随机数(推荐)
*/3.3 Calendar日历（抽象类）
提供了获取年，年中的月
/**
* java.util.Calendar:日历类(抽象类)
* 提供了获取年,年中的月,月中的日期,小时,小时分钟数,分钟中的秒数都可以获取到
*
* 如果有一个类是抽象类,可以直接new子类,或者是它提供了一些静态方法---->
* 完成了一些事情,创建子类对象,返回值是当前抽象类的本身
*
* 成员方法:
* public static Calendar getInstance() 创建日历对象
* public int get(int field):通过日历对象获取日历中的字段值
*
* 参数:Calendar中提供的一些静态字段
* public static final int YEAR:年份
* public static final int DAY_OF_MONTH/public static final int DATE:月中的日期
* public static final int MONTH:月份
*
* public abstract void add(int field,int amount):给指定的日历字段值添加或者减去时间偏移量
*
*/3.4 BigDecimal
/**
*BigDecimal这个类是对小数可以进行精确计算的!
* 构造方法:
*
* public BigDecimal(String val):将String类型数据构造成BigDecimal
* 将double数据---使用"小数字符串"
*
* 成员方法:
* public BigDecimal add(BigDecimal augend):求和
* public BigDecimal subtract(BigDecimal subtrahend):相减
* public BigDecimal divide(BigDecimal divisor):小数除法
* public BigDecimal divide(BigDecimal divisor,int roundingMode):除法,第二个参数舍入模式
*
* BigDecimal提供的模式 public static final int ROUND_HALF_UP:四舍五入
* ...
* public BigDecimal divide(BigDecimal divisor,
* int scale,//保留几位小数
* int roundingMode) //舍入模式
* public BigDecimal multiply(BigDecimal multiplicand):乘法
*/3.5 Pattern
public final class Pattern extends Object implements Serializable 正则表达式的编译表示。
○ Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
这个类定义了一个matches方法，以便在正则表达式只使用一次时方便。
○ 正则表达式跟前端js里面的一样，所以在前端里面在讲3.6 Date(重点)
/**
* java.util.Date:表单特定的日期时间,还允许格式化和解析日期字符串
* 构造方法:
* public Date():创建当前日期对象:获取当前系统日期时间
* public Date(long date):里面传入long类型的时间毫秒值,获取的表示从标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数
*成员方法:
* public long getTime():将Date对象转换成long类型时间毫秒值
* public void setTime(long time):设置日期时间,参数时间毫秒值3.6.1 Date和String日期文本相互转换
他们之间要进行转换需要使用类DateFormat
* DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间
* 它具体的子类:SimpleDateFormat是一个具体的类,允许格式化（日期文本），解析（文本日期）
*
*构造方法:
* public SimpleDateFormat(String pattern):参数是日期模式 "yyyy-MM-dd"
* pattern的组成:
* y:表示年份中某个值----->yyyy 表示年 "1996/2023/..."
* M:表示年中的月份------>MM 表示月:七月-->"07" 十月 -->"10"
* d:表示月中的日期值----->dd 表示 "01","11","31"..
* 成员方法
* 将Date---->String:格式化 public final String format(Date date)
* 将String日期---->Date:解析
*
* public Date parse(String source)throws ParseException
*/四、集合
4.1 集合的概念：
集合、是一个容器，它可以存储不同数据类型的元素，当这些元素必须为引用数据类型，集合长度可变！4.2 集合和数组区别
1)长度区别
* 数组:固定
* 集合:可变
* 2)存储数据类型的区别?
* 数组:可以存储基本数据类型,也可以存储引用数据类型
* Student[] students = new Student[5] ;//引用类型
* int[] arr = new int[5] ; //基本数据类型
* 集合:只能存储引用类型 集合<泛型>
* 3)存储元素的区别?
* 数组:数组存储的元素的数据类型必须一致
* int[] arr = new int[5] ;
* arr[0] = "hello" ; //不行
* 集合:如果没有明确<泛型>,可以存储任意的引用类型(包含Object)4.3 Collection
Collection:单例集合顶层次的根接口,不能new,没有直接子实现类,是通过它子接口的子实现类来实例化!
* 泛型: 集合里面创建的时候,如果不带泛型可能程序安全问题;带了<>,模拟创建数组的时候,明确了数据类型!
* <E>:element
* <T>:Type
* <K>:Key键
* <V>:Value值
*
* 基本功能:
* 添加元素:
* boolean add(E e):添加元素
* 删除:
* boolean remove(Object o):删除指定的元素
* void clear():暴力删除:清空集合
* 判断:
* boolean contains(Object o):是否包含指定的元素
* boolean isEmpty():判断集合是否为空
*
Collection<String> c = new ArrayList<>() ;
//=后面的集合的<> jdk7以后新特性；泛型推断 (加入泛型:保证数据的安全性),创建集合就明确了数据类型
4.3.1 Collection集合高级功能
* Object[] toArray():集合的传统方式遍历 将集合转换成对象数组(以后不会用的)
* Iterator<E> iterator():Collection专有迭代器(遍历集合) (过渡)
/**
*Iterator<E> iterator():Collection专有迭代器(遍历集合) (过渡)
*
* Iterator迭代器接口:
* boolean hasNext(): 判断迭代器里面是否下一个可以遍历的元素
* E next():获取迭代器的下一个元素 (和迭代器中的类型一致)
*
//获取Collection的迭代器
//Iterator<E> iterator()
Iterator<String> it = c.iterator();
//E next() //E---类型需要和泛型的类型一致的
* 开发中---集合遍历---->都用jdk5以后新特性:增强for循环 代替上面迭代器
4.3.2ConcurrentModificationException
需求:
* 有一个Collection集合,存储一些不重复的String元素,如果现在里面有"world",需要给集合中
* 添加一个新的"JavaEE"元素!
*
* 分析:
* 1)创建Collection,模拟存储一些字符串,里面就包含"world"
* 2)获取Collection集合迭代器,遍历元素,
* 3)判断,如果这里面存在"world",然后添加"JavaEE"
*
*
* 出现了异常"ConcurrentModificationException":并发修改异常
*
* 什么叫并发:在某个时间点上同时进行!
* 在集合这块出现ConcurrentModificationException原因:
* 当使用迭代器去遍历元素的时候,同时不能使用集合对象去操作(修改或添加...)元素,就会出现这个异常!
* 因为,迭代器在遍历元素的时候,集合添加一个新的元素,迭代器不知道!
* 解决方案:
*
* Collection没有直接操作----->子接口List特有功能(ListIterator:列表迭代器/List集合普通for+size()+get(int index))
* 1)集合遍历,集合添加------>List集合普通for+size()+get(int index)
* 2)迭代器遍历,迭代器添加------->列表迭代器遍历元素，迭代器添加元素（ListIterator----void add(E e)将指定元素插入列表，
不是在集合尾部添加，与Collection的add方法不一样！
4.3.3增强for循环
Jdk5新特性:<泛型>,增强for,可变参数,静态导入(导入到方法级别:方法必须静态)...
*
*
* 增强for:是在集合/数组中存储的引用类型中使用居多,代替集合迭代器的,简化书写代码
* 格式:
* for(集合中存储的数据类型 变量名 : 集合对象){
* 使用这个变量名即可;
* }
*
* 注意:
* 要使用增强for遍历集合,集合对象不能null;
* 防止空指针异常,在使用增强for之前,对集合进行非空判断!4.4 List集合
List集合常用三个子实现类特点：
实际需求;单线程中，使用List完成一些事情，没有明确规定具体使用哪个实现类时，默认使用ArrayList集合！
默认ArrayList
底层数据结构是数组---->查询快，增删慢（数组，通过整数索引查询）
元素查找：
顺序查找、二分搜索（折半查找），哈希查找
43,50,66,70,---->哈希查询,哈希表的长度10
43 % 10 = 3
线程角度：
线程不安全的类，是一个不同步，执行效率高！
底层扩容机制1.5倍
Vector
底层数据结构是数组---查询快，增删慢
线程角度:
线程安全的类,是同步的,执行效率低! 多线程环境下使用居多,单线程使用ArrayList代替Vector
LinkedList
底层数据是链表, 查询慢,增删快
线程角度:
线程不安全的类,不同步的,执行效率高!
**
* List集合特点:
* 元素有序(存储和取出一致),而且元素可以重复!
* Set集合:
* 元素唯一的,无序(存储和取出不一致)
*
*List集合是Collection集合的子接口,它集合遍历方式:
* 1)Collection的Object[] toArray()
* 2)Collection的Iterator iterator() ;
* 3)使用size()+ 存储的数据类型 get(int index)通过角标获取元素内容 :普通for循环格式
* 4)ListIterator<E> listIterator()List集合的专有遍历方式 :列表迭代器
* 5)增强for循环
@SuppressWarnings("all") //压制所有警告 "jdk提供注解"
List集合的专有遍历方式 :列表迭代器
//列表迭代器提供了一些功能,进行逆序遍历(前提必须有上面的正向遍历)
4.4.1 Vector
1.Vector:底层数组，查询快，增删慢，线程安全的，执行效率低
2.Vector集合特有功能：
遍历方式：
Collection的Object[] toArray
Collection的Iterator iterator()
List接口提供的size()+get(int index)
List接口提供的ListIterator listiterator()
特有遍历方式
public Enumeration<E> elements()--->相当于集合的迭代器
Enumeration接口:枚举组件
boolean hasMoreElements()---->相当于boolean hasNext()
E nextElement() ---->相当于E next()
public E elementAt(int index)--->相当于List的get(int index)+size方法相结合
*
* 增强for
*
* 添加:
* public void addElement(E obj)--->相当于List的add()
* public E elementAt(int index)--->相当于List的get(int index)
4.4.2 LinkedList
LinkedList的特有方法：
* public void addFirst(E e) :在链表开头插入元素
* public void addLast(E e) :在链表末尾插入元素
* public E removeFirst(): 删除链表开头的第一个元素并返回该元素
* public E removeLast()从此列表中删除并返回最后一个元素。
* public E getFirst():返回链表头元素
* public E getLast():返回链表链尾元素
* 需求:
* 利用LinkedList模拟栈的结构特点,先进后出
*
* 自定义类--->里面使用到LinkedList的特有功能
* 方法add()--->linkedList的addFirst()
* get()--->获取元素: LinkedList的removeFirst()删除并返回
* 自定义一个方法isEmpty()--->判断LinkedList是否为空
4.5 Set集合
4.5.1 Set接口特点
/**
* 无序(存储和取出不一致),不能保证迭代次序,但是可以唯一!
* HashSet<E> : 存储和取出,保证元素唯一!
* ---底层是HashMap实例(哈希表)
* TreeSet<E> : 存储和取出,同时需要进行排序的取出!
* ---底层是依赖TreeMap实例(红黑树结构)
//必须实现接口Compareable,自然排序4.5.2 TreeSet<E>有两种排序方式
自然排序:
* public TreeSet():使用自然排序,当前里面存储的类型必须实现Comparable
* 比较器排序
590
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
