局部内部类, 它的书写位置, 在外部类的成员方法中的定义类
局部内部类可以访问外部类的成员变量包括私有
在外部类的局部位置, 访问内部类的成员方法, 创建当前局部内部类对象来访问
class Outer {
public int num = 100 ;
private int num2 = 200 ;
public void method ( ) {
class Inner {
public void show ( ) {
System . out. println ( num) ;
System . out. println ( num2) ;
}
}
Inner inner = new Inner ( ) ;
inner. show ( ) ;
}
}
public class OuterDemo {
public static void main ( String [ ] args) {
Outer outer = new Outer ( ) ;
outer. method ( ) ;
}
}
☆☆☆面试题:
局部内部类访问局部变量的时候, 此时局部变量应该注意什么? ( JDK7/ JDK8) , 为什么要加入final 关键字呢?
如果此时java环境是JDK7, 局部内部类访问局部变量时, 此时该变量必须手动显示加入final 关键字
环境是JDK8环境, 此时局部内部类访问局部变量, 局部变量不需要显示给出final , jvm做优化, 通过反编译工具查看局部内部类
外部类名$内部类名. class
当前局部变量-- -- -> 已经加入final 关键字
加入final 关键字, 此时变量是常量
class Outer2 {
public void method ( ) {
int num = 20 ;
class Inner2 {
public void show ( ) {
System . out. println ( num) ;
}
}
Inner2 inner2 = new Inner2 ( ) ;
inner. show ( ) ;
}
}
public class OuterDemo2 {
public static void main ( String [ ] args) {
Outer2 . outer = new Outer2 ( ) ;
outer2. method ( ) ;
}
}
匿名内部类: 没有名字的内部类, 一般在我们局部位置使用!
格式: 匿名内部类它是内部类的一种简化格式
new 类名( 可以是抽象类, 也可以是具体类) 或者是接口( ) {
重写功能
} ;
匿名内部类的本质:
继承了该类或者是实现了该接口的子类对象
interface Inner {
void show ( ) ;
void show2 ( ) ;
}
class Outer3 {
public void method ( ) {
Inter i = new Inter ( ) {
public void show ( ) {
System . out. println ( "show Inter" ) ;
}
public void show2 ( ) {
System . out. println ( "show2 Inter" ) ;
}
} ;
i. show ( ) ;
i. show2 ( ) ;
}
}
public class OuterDemo3 {
public static void main ( String [ ] args) {
Outer3 outer3 = new Outer3 ( ) ;
outer. method ( ) ;
}
}
public String toString ( ) : 对象的字符串表现形式, 结果应该简明扼要, 易于读懂的表达式( 成员信息表达式)
需要建议子类重写这个方法, 否则如果直接输出对象名称, 打印出来是一个"地址值" , 没有意义
Student s = new Student ( "张三" , 20 , "男" ) ;
如果不重写object的toString ( ) , 直接输出s, -- -- -> 等价于 s. toString ( ) -- -- -- >
this . getClass ( ) . getName ( ) + "@" + Integer . toHexString ( this . hashCode ( ) )
重写tostring ( ) -- -> alt+ ins-- -- > toString ( )
类名{ [ name= "张三" , age= 20 , sex= "男" ] }
public boolean equals ( Object obj)
== 和equals
== : 如果连接的基本数据类型: 比较数据值是否相同
== : 如果连接的引用数据类型: 比较的是对象的地址值是否相同
Student s1 = new Student ( "张三" , 20 , "男" ) ;
Student s2 = new Student ( "张三" , 20 , "男" ) ;
s1. equals ( s2) ; -- -- -- ->
equals: 如果不重写Object 的equals, 它默认比较的是两个对象的地址值是否相同
return ( this == obj) ;
建议子类重写equals方法的同时, 还需要重写hashCode ( ) ( 对象不同, 哈希码值是不相同的)
alt+ ins-- -- -> equals and hashCode ( ) -- -- > idea default
重写之后: s1. equals ( s2) ; -- -- -- -- -- > true
String 类型-- - 底层已经对Object 的equals重写了, 所以String 的equals就比较的是字符串内容是否相同
Object类的getClass()方法
任意java类型的class属性: String.class Student.class...
反射中使用:Class.forName("包名.类名(类的全限定名称)");
外部类名.内部类名 对象名 = new 外部类名.内部类名();
克隆方法
protected Object clone ( ) throw CloneNotSupportedException : 创建对象并返回该对象的副本
这个方法会抛出一个异常, throws : 表示的是可能出现异常, 针对调用者必须进行处理
要使用clone方法, 当前某个对象所在的类必须实现"标记接口" Cloneable ( 没有字段( 成员变量) ) , 也没有成员方法, 实现这个接口, 那么就可以使用Object 的clone ( ) 方法\
练习题:
public class ObjectDemo {
public static void main ( String [ ] args) throws CloneNotSupporedException {
Student s1 = new Student ( "张三" , 20 ) ;
System . out. println ( s1) ;
System . out. println ( s1. getName ( ) + "---" + s1. getAge ( ) ) ;
System . out. println ( "-----------------------------" ) ;
Object obj = s1. clone ( ) ;
Student s2 = ( Student ) obj;
System . out. println ( s2) ;
System . out. println ( s2. getName ( ) + "-----" + s2. getAge ( ) ) ;
System . out. println ( "-------------------------------" ) ;
Student s3 = s1;
System . out. println ( s3. getName ( ) + "------" + s3. getAge ( ) ) ;
}
public class Students implements Cloneable {
private String name;
private int age;
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 Student ( ) {
}
public Student ( String name, int age) {
this . name = name;
this . age = age;
}
@Override
public String toString ( ) {
return "Student{" +
"name=''" + name+ '\'' +
", age=" + age +
'}' ;
}
@Override
protected Object clone ( ) throws CloneNotSupportedException {
return super . clone ( ) ;
}
}
java. lang. String: 代表的字符串
字符串是一个常量, 一旦被赋值, 其值( 地址值) 不能被更改
推荐使用的方式:
String 变量名 = "xxxx" ;
String 类常用的功能:
获取功能: int length ( ) : 获取字符串长度
构造方法:
public String ( ) : 空参构造, 空字符序列
public String ( byte [ ] bytes) : 将一个字节数组构造成一个字符串, 使用平台默认的字符集( utf- 8 : 一个中文对应三个字节) 解码
编码和解码-- - 保证字符集统一
编码: 将一个能看懂的字符串-- -- > 字节
解码: 将看不懂的字节-- -- > 字符串
public String ( byte [ ] bytes, 字符集) : 使用指定的字符集, 将字节数组构造成一个字符串
public String ( byte [ ] bytes, int offset, int length) : 将指定的部分字节数组转换成字符串
参数1 : 字节数组对象 参数2 : 指定的角标值 参数3 : 指定长度
public String ( char [ ] value) : 将字符数组构造成一字符串
public String ( char [ ] value, int offset, int count) : 将部分字符数组转换成字符串
public String ( String original) : 构造一个字符串, 参数为字符串常量
☆☆☆面试题
在数组中有没有length方法, 在String 类中有没有length方法, 在集合中有没有length方法?
数组中没有length方法, length属性
String 类中又length ( )
集合中没有length ( ) , -- -- > size ( ) 获取元素数
☆☆☆面试题:
String s1 = "hello" ;
String s2 = new String ( "hello" ) ;
在内存中分别创建了几个对象?
第一个: 创建了一个对象, 直接在常量池创建, 开辟常量池空间
第二个: 创建了两个对象, 一个在堆内存中开辟空间, 一个指向常量池( 不推荐)
public class StringDemo {
public static void main ( String [ ] args) {
String s1 = "hello" ;
String s2 = new String ( "hello" ) ;
System . out. println ( s1== s2) ;
System . out. println ( s1. equals ( s2) ) ;
}
}
public boolean equals ( Object anObject) : 比较两个字符的内容是否相同( 区分大小写)
public boolean equalsgnoreCase ( String anotherString) : 比较两个字符串是否相同( 不区分大小写)
public boolean startsWith ( String prefix) : 判断字符串是否以指定的内容开头
public boolean endsWith ( String suffix) : 判断字符串是否以指定的内容结尾
boolean isEmpty ( ) 判断字符串是否为空, 若为空, 则返回true , 否则返回false
String s = "" ;
String s = null ;
String 类的常用的转换功能:
byte [ ] getBytes ( ) { } : 将字符串转换成字节数组( 编码)
如果方法为空参, 使用平台默认的编码集进行编码( utf- 8 : 一个中文对应三个字节)
byte [ ] getBytes ( String charset) : 使用指定的字符集进行编码
String ( byte [ ] bytes) { } : 使用默认字符集进行解码
String ( byte [ ] bytes, 指定字符集)
编码和解码必须要保证字符集统一
Arrays 静态功能: Arrays . toString
public static String toString ( int / byte / float / double . . [ ] a) : 将任意类型的数组-- -- -- > String
public char [ ] toCharArray ( ) : 将字符串转换成字符数组
public String toString ( ) : 返回自己本身-- - "当前字符串的内容"
public String toUpperCase ( ) : 将字符串转换成大写
public String toLowerCase ( ) : 将字符串转换成小写
int length ( ) : 获取字符串长度
public char charAt ( int index) ; 获取指定索引处的字符
public String conCat ( String str) : 将指定的字符串和当前字符串进行拼接, 获取一个新的字符串
public int indexOf ( int ch) : 返回指定字符第一次出现的索引值
public int lastIndexOf ( int ch) : 返回指定字符最后一次出现的索引值
public String [ ] split ( String regex) : 拆分功能, 通过指定的格式字符串-- > 拆分字符串数组
public String substring ( int beginIndex) : 从指定位置开始默认截取到末尾, 角标从0 开始
public String substring ( int beginIndex, int endIndex) : 从指定位置开始, 截取到位置结束( 包前不包右) , 只能取到endIndex- 1 处
public static String valueOf ( boolean / int / long / float / double / char . . . Object b) : 万能方法, 将任意类型转换String 类型
public String replace ( char target, char replacement) : 替换功能, 将指定的内容使用target字符进行替换
public String replaceAll ( String regex, String replacement) :
将指定的和参数1 正则表达式匹配的字符串使用replacement进行替换
参数1 : [ 0 - 9 ] -- -- -- -> 如果字符是数字字符
参数2 : "*" 替换掉
public String trim ( ) : 去除字符串两端的空格
public int compareTo ( String anotherString) : 按照字典顺序比较, 返回值是int
import java. util. Scanner ;
public class StringTest {
public static void main ( String [ ] args) {
Scanner sc = new Scanner ( System . in) ;
System . out. println ( "请您输入一个字符串(大小写字母):" ) ;
String line = sc. nextline ( ) ;
String s1 = line. subString ( 0 , 1 ) ;
String s2 = s1. toUpperCase ( ) ;
String s3 = line. substring ( 1 ) ;
String s4 = s3. toLowerCase ( ) ;
String result = s2. concat ( s4) ;
System . out. println ( result) ;
}
}
StringBuffer : 字符串缓冲区-- -> 类似于String , 但是不一样( 可变的字符序列)
StringBuilder : 和StringBuffer 具有相互兼容的API, 它是线程不安全的类-- -> 不同步-- -> 执行效率高
单线程程序中: jvm在进行编译的时候, 使用StringBuilder 去替换StringBuffer
StringBuffer 的构造方法
public StringBuffer ( ) : 空参构造, 创建一个空字符序列的字符串缓冲去( 推荐)
public StringBuffer ( int capacity) : 构造一个字符串缓冲区对象, 指定容量大小
public StringBuffer ( String str) : 指定字符串序列, 长度加上初始容量16 ( 总容量)
获取功能:
public int length ( ) : 获取字符数( 长度)
public int capacity ( ) : 获取字符串缓冲区容量
将字符串每一个字符分别输出
可以使用String 类的获取功能: charAt ( int index) -- -- > char
public class StringTest {
public static void main ( String [ ] args) {
String str = "helloJavaEE" ;
for ( int x = 0 ; x< str. length ( ) ; x++ ) {
System . out. println ( str. charAt ( x) ) ;
}
System . out. println ( "----------------------" ) ;
char [ ] chs = str. toCharArray ( ) ;
for ( int x= 0 ; x< chs. length; x++ ) {
char ch = chs[ x] ;
System . out. println ( ch) ;
}
}
}
public class StringTest2 {
public static void main ( String [ ] args) {
int [ ] arr = { 11 , 22 , 33 , 44 , 55 } ;
String str = array2String ( arr) ;
System . out. println ( str) ;
}
private static String array2String ( int [ ] arr) {
String result = "" ;
result += "[" ;
for ( int x = 0 ; x< arr. length; x++ ) {
if ( x== arr. length- 1 ) {
result += arr[ x] ;
result += "]" ;
} else {
result += arr[ x] ;
result += ", " ;
}
}
return result;
}
}
public class StringTest3 {
public static void main ( String [ ] args) {
Scanner sc = new Scanner ( System . in) ;
System . out. println ( "请您输入一个字符串:" ) ;
String line = sc. nextLine ( ) ;
String result = reverse ( line) ;
System . out. println ( result) ;
}
private static String reverse ( String s) {
String result = "" ;
char [ ] chs = s. toCharArray ( ) ;
for ( int x = chs. length- 1 ; x>= 0 ; x-- ) {
result += chs[ x] ;
}
return result;
}
}
StringBuffer : 线程安全的( 执行效率低) : 字符缓冲区: 里面存储的字符序列
添加功能:
StringBuffer append ( 任何类型) : 将内容追加到字符串缓冲区( 在字符串缓冲区的最后一个字符序列的末尾追加)
返回值是字符串缓冲区本身
public StringBuffer insert ( int offest, String str) : 插入: 在指定位置处插入指定的内容
public StringBuffer deleteCharAt ( int index) : 删除指定索引处的缓冲区的字符序列, 返回字符串缓冲区本身
public StringBuffer delete ( int start, int end) : 删除从指定位置到指定位置结束的字符序列( 包含end- 1 处的字符) , 返回字符缓冲区本身
String s = "hello" ;
StringBuffer sb = new StringBuffer ( s)
StringBuffer sb = new StringBuffer ( ) ;
sb. append ( s) ;
StringBuffer buffer = new StringBuffer ( "world" ) ;
String str = new String ( buffer) ;
public StringBuffer reverse ( ) , 反转之后, 返回的是字符串缓冲区本身
public String substring ( int start) : 从指定位置开始, 默认截取到末尾, 返回值是新的字符串
public String substring ( int start, int end) : 从指定位置开始到指定end- 1 结束进行截取, 返回新的字符串
StringBuffer 的替换功能
public StringBuffer replace ( int start, 起始索引
int end, 结束索引
String str) 替换的内容
共同点: 都是容器, 都可以存储任意类型的元素, 可以存储基本类型, 也可以存储引用类型
数组: 只能存储同一种数据类型容器
数组的最大的特点: 长度固定
静态初始化 int [ ] arr = { 元素1 , 元素2 , 元素3. . . } ;
动态初始化 int [ ] arr = new int [ 长度] ;
String strArray = { "xx" , "xx" , "xx" } ;
StringBuffer : 支持可变的字符序列, 里面可以存储不同类型的元素 长度是可变的
append ( int / char / double / float / Object / String )
insnert ( int offert, int / char / double / float / Object / String )
一般情况: 开发中将StringBuffer -- -- -- > String
String : 字符串是一个常量, 一旦别赋值, 其值不能更改, 作为形式参数属于特殊的引用类型, 形式参数的改变不会影响实际参数
StringBuffer : 可变的字符序列, 线程安全的类-- -- 同步的-- - 执行效率低( 多线程: 同步锁)
StringBuilder : 可变的字符序列, 和StringBuffer 具有相互兼容的api, 单线程程序中( 只考虑执行效率, 不考虑安全问题) , 会使用StringBuilder 替代StringBuffer , 多线程环境中, 要考虑安全问题只能使用StringBuffer
Integer : int 类型的包装类类型( 引用类型) , 包含了int 类型的原始数据值
基本类型四类八种都有对应的各自的引用类型
需要基本类型和String 类型之间转换: 需要中间桥梁( 基本类型对应的包装类类型) int -- -- > String
整数类型 引用类型
byte -- -- > Byte
short -- -- > Short
int -- -- -> Integer
long -- -- -> Long
浮点类型
float -- -- -> Float
double -- -- -> Double
字符类型
char -- -- -- > Character
布尔类型
boolean -- -- -> Boolean
进制的转换-- -- -> 可以使用Integer 静态功能
通过Integer 得到int 类型的取值范围
public static String toBinaryString ( int i) : 将整数-- -- > 二进制的字符串
public static String toOctalString ( int i) : 将整数-- -- > 八进制的字符串
public static String toHexString ( int i) : 将整数-- -- -> 十六进制数据
public static final int MAX_VALUE: int 的最大值
public static final int MIN_VALUE: int 的最小值
Integer 的构造方法
Integer ( int value) : 可以将int 类型保证为Integer 类型
Integer ( String s) throws NumberForamtException : 抛出一个数字格式化异常
注意事项: 当前字符串如果不是能够解析整数, 就会出现数字格式化异常, s必须为数字字符串
JDK5以后新特性:自动拆装箱,可变参数,静态导入,增强for循环,<泛型>,枚举类
自动拆装箱: 基本类型--->对应的包装类型 (装箱) int---->Integer
对应的包装类型----->基本类型(拆箱)
public class IntegerTest {
public static void main ( String [ ] args) {
Integer i1 = new Integer ( 127 ) ;
Integer i2 = new Integer ( 127 ) ;
System . out. println ( i1== i2) ;
System . out. println ( i1. equals ( i2) ) ;
System . out. println ( "---------------------" ) ;
Integer i3 = 127 ;
Integer i4 = new Integer ( 127 ) ;
System . out. println ( i3== i4) ;
System . out. println ( i3. equals ( i4) ) ;
System . out. println ( "-------------------------" ) ;
Integer i5 = 128 ;
Integer i6 = new Integer ( 128 ) ;
System . out. println ( i5== i6) ;
System . out. println ( i5. equals ( i6) ) ;
System . out. println ( "--------------------------" ) ;
Integer i7 = 127 ;
Integer i8 = 127 ;
System . out. println ( i7== i8) ;
System . out. println ( i7. equals ( i8) ) ;
System . out. println ( "----------------------------" ) ;
Integer i9 = 128 ;
Integer i10 = 128 ;
System . out. println ( i9== i10) ;
System . out. println ( i9. equals ( i10) ) ;
}
}
char 类型的包装类类型
构造方法: public Character ( char value)
主要功能:
public static boolean isUpperCase ( char ch) : 判断当前字符是否大写字母字符
public static boolean isLowerCase ( char ch) : 是否为小写字母
public static boolean isDigit ( char ch) : 是否为数字字符
public static char toLowerCase ( char ch) : 将字符转换成小写
public static char toUpperCase ( char ch) : 将字符转换成大写
java. util. CalendarCalendar : 提供一些诸如获取年, 月, 日中的日期等等字段值
静态功能, 返回值是它本身 public static Calendar getInstance ( )
成员方法:
public int get ( int field) : 根据给定日历字段-- -- - 获取日历字段的值( 系统的日历)
public abstract void add ( int field, int amount) : 给指定的日历字段, 添加或者减去时间偏移量
参数1 : 日历字段
参数2 : 偏移量
Java . util. Date: 表示特定瞬间, 精确到毫秒, 允许格式化和解析日期字符串
构造方法:
public Date ( ) : 当前系统时间格式
public Date ( long date) : 参数为: 时间毫秒值-- -- -> Date 对象( 1970 年1 月1 日)
Java . util. Date-- -- > String 格式化过程
DateForamt : 抽象类-- -- 提供具体的日期/ 格式化的子类: SimpleDateFormat
SimpleDateFormat : 构造函数
public SimpleDateFormat ( ) : 使用默认模式
public SimpleDateFormat ( String pattern) : 使用指定的模式进行解析或者格式( 推荐)
参数: 一种模式
表示年 "yyyy"
表示月 "MM"
表示月中的日期 "dd"
一天中小时数 "HH"
分钟数 "mm"
秒数 "ss"
public Date parse ( String sourse) throws ParseException
如果解析的字符串的格式和public SimpleDateFormat ( String pattern) 的参数模式不匹配的话, 就会出现解析异常
java . util. Date-- -- -- > String
格式化操作:
Date date = new Date ( ) ;
SimpleDateFormat sdf = new SimpleDateFormat ( "yyyy-MM-dd" ) ;
String textDate = sdf. format ( date) ;
String sourse = "2021-7-29" ;
SimpleDateFormat sdf2 = new SimpleDateFormat ( "yyyy-MM-dd" ) ;
Date date2 = sdf2. parse ( sourse) ;
public static String toString ( int i)
public static int parseInt ( String s)
String s = "100" ;
Integer i = new Integer ( s) ;
int num = i. intValue ( ) ;
构造方法
public Random ( ) : 产生一个随机生成器对象, 通过成员方法随机数每次是不一样的( 推荐)
public Random ( long seed) : 参数为long 类型的值, 每次通过成员方法获取随机数产生的随机数相同的
获取随机数的成员方法
public int nextInt ( ) : 获取的值得范围是int 类型的取值范围( - 2 的31 次方到2 的31 次方- 1 )
public int nextInt ( int n) : 获取0 ~ n之间的数据( 不包含n)
产生随机数:
MAth 类的random方法 public static double random ( ) ;
Random 类: 无参构造+ 成员方法 public Random ( ) : + public int nextInt ( int n)
public static int abs ( int a) : 绝对值方法
public static double ceil ( double a) : 向上取整
public static double floor ( double a) : 向下取整
public static int max ( int a, int b) : 获取最大值
public static int min ( int a, int b) : 获取最小值
public static double pow ( double a, double b) : a的b次幂
public static double random ( ) : 随机数
public static long round ( double a) : 四舍五入
public static double sqrt ( double a) : 开平方根
MAth 类中的功能都是静态的, 里面构造方法私有化
工具类中的构造方法都是会私有化( 自定义的工具类) , 提供对外静态的公共访问方法
小数要进行精确计算, 还可以计算的同时保留小数点后的有效位数 Java 提供的类: BigDecimal
构造方法:
public BigDecimal ( String value) : 数字字符串
成员方法:
public BigDecimal add ( BigDecimal augend) 加
public BigDecimal subtract ( BigDecimal subtrahend) 减
public BigDecimal multiply ( BigDecimal multiplicand) 乘
public BigDecimal divide ( BigDecimal divisor) 除
public BigDecimal divide ( BigDecimal divisor, int scale, int roundingMode)
参数1 : 商
参数2 : 小数点后保留的有效位数
参数3 : 舍入模式: 四舍五入
List集合有序,存储和 取出一致的,可以允许元素重复
Set集合无序,存储和取出不一致,不允许元素重复(元素唯一)
面试题: 集合和数组有什么区别?
1 ) . 长度区别
数组: 长度固定
集合: 长度可变
2 ) . 存储数据类型的区别
数组: 可以存储基本数据类型, 也可以存储引用数据类型
集合: 前提条件: 集合中加入泛型< > Collection < E > : 泛型< 引用类型>
3 ) . 存储元素的区别:
数组: 存储的元素必须为同一种数据类型
集合: 如果没有加入泛型 : 就可以存储任意类型的元素( 必须引用类型)
Collection : 集合层次的根接口, 一些集合允许元素重复( List ) , 一些集合不允许元素重复( Set ) , 一些集合有序( 存储和取出一致) ( List ) , 一些集合无序( 存储和取出的不一致) ( Set )
JDK不提供次接口的任何直接实现: 它提供了更具体的子接口的实现, 如Set 和List
基本功能:
添加: boolean add ( Object e) : 添加元素 E ( Element )
删除: void clear ( ) 暴力删除( 将集合中所有元素全部删除)
boolean remove ( Object o) : 从集合中删除指定的元素
获取集合的元素数: int size ( )
判断功能: boolean isEmpty ( ) : 判断集合是否为空, 为空元素, 则返回true
boolean contains ( Object o) : 判断集合中是否包含指定元素, 包含则返回true
添加:
boolean addAll ( Collection c) : 添加一个集合中的所有元素
boolean containsAll ( Collection c) : 包含一个集合中的所有元素
删除:
boolean removeAll ( Collection c) : 删除集合中的所有元素( 删除一个算删除, 必须同时都被包含进去)
boolean retainAll ( Collection c) : A 集合对B 集合求交集, 交集的元素存储在A 集合中, 然后返回值的意思: 看A 集合的元素是否有变化( 之前的元素和现在交集额元素进行对比) , 如果有变化, 返回true , 没有变化, 则返回false
Collection 最基本的遍历功能, 不属于集合的专有遍历
Object [ ] toArray ( ) : 将集合转换成了对象数组
迭代器的本质:实现了Interator接口的子实现类对象(ArrayList的成员内部类)
Iterator iterator():返回值类型接口类型,需要返回的子实现类对象
Interator接口:
boolean hasNext():判断迭代器中是否存在下一个元素
Object next(): 获取下一个可以遍历的元素
Collection < String > = new ArrayList < String > ( ) ;
c. add ( "hello" ) ;
c. add ( "javaee" ) ;
c. add ( "javaweb" ) ;
Object [ ] obj = c. toArray ( ) ;
for ( int x = 0 ; x< obj. length; x++ ) {
System . out. println ( obj[ x] ) ;
}
Collection < String > = new ArrayList < String > ( ) ;
c2. add ( "hello" ) ;
c2, add ( "world" ) ;
c2, add ( "javaee" ) ;
Interator < String > = c2. iterator ( ) ;
while ( it. hasNext ( ) ) {
String str = it. next ( ) ;
System . out. println ( str) ;
}
内部具备一个指针,当在第一次获取元素的时候,指针处在第一个元素前面的位置;当通过hasNext()判断,如果存在下一个可以迭代的元素,那么指针就会向下一个索引进行移动,并且next()获取前面的元素,依次这样操作,直到hasNext()为false的时候,没有元素了,指针就不会在移动;Interator是一个接口,具体的移动的操作是通过ArrayList的成员内部类Itr来进行实现
泛型的格式:
<引用数据类型>
模拟数组创建的时候,就已经明确了数据类型
创建集合对象的时候,明确了集合中存储的数据类型<>
集合类型<引用数据类型> 集合对象名 = new 子实现类<引用数据类型>();
泛型的好处:
1).将运行时期异常提前了编译时期
2).避免了强制类型转换
3).提高了程序安全性
特点: 有序( 存储元素和取出元素一致) 允许元素重复
特有功能:
void add ( int index, Object element) : 在指定的索引处插入元素
Object get ( int index) : 获取指定位置处的元素 + int size ( ) : 一种新的集合遍历方式
Object remove ( int index) : 删除指定位置处的元素
Object set ( int index, E element) : 修改指定位置处的元素( 替换)
ListIterator < E > listIterator ( ) : 列表迭代器
Object [ ] toArray ( )
Iterator iterator ( )
Object get ( int index) : 获取指定位置处的元素 + Int size ( ) : 一种新的集合遍历方式
< ? > : 任意类型包括Object < ? extends E > < ? super E > : 通配符
java. util. ConcurrentModificationException-- -- -> 并发修改异常
集合在使用迭代器会经常出现的问题: 并发修改异常
当集合的元素正在被迭代器进行遍历, 那么集合对象是不能够对元素进行增加或者删除( 一个线程正在遍历, 一个线程正在修改元素)
解决方法:
1 ) . 要么就是迭代器去遍历集合的元素, 迭代器去添加元素: 列表迭代器才具备添加的动作
2 ) . 要么集合遍历, 集合添加
JDK五以后,提供了增强for循环,替代集合中迭代器去遍历集合使用的(优先在集合中使用)
格式:
for(存储的引用数据类型 变量名: 集合/数组对象){
//集合使用居多,数组一般都是使用普通for使用变量名即可
}
注意事项:
当前集合对象不能为空 null:foreach语句,增强for它本身就是获取了迭代器,就会出现空指针异常
方法1. 新建空集合思想
存储字符串类型并保证集合的元素唯一 List < String > Collection / List -- -> contains ( Object 0 ) 底层依赖于Object 的equals方法, 而List 现在存储的是String 类型, 本身重写Object 的equals, 所以比较的是内容是否相同
方法2. 条件: 不重新新建一个List 集合, 利用选择排序的思想去完成
选择排序的思想: 使用0 角标对应的元素依次和后面角标对应的元素进行比较, 小的往前方法, 依次这样比较, 1 角标, 2 角标. . .
List 集合-- - 集合列表角标从0 开始
遍历当前集合
然后使用0 角标对应的元素依次和后面对应的元素进行比较, 如果后面的元素和前面的相同, 那么将后面的元素删除掉
List < > , 去重方法:
方式1. 新建集合思想
contains ( Object ) 方法依赖于Object 的equals方法, 所以集合存储的类型所在的类必须重写equals方法, 否则默认使用Objeect 的equals方法比较地址值是否相同
方式2. 使用选择排序思想, 将List < > 添加:
public void addElement ( Object obj) : 在vector对象的末尾添加元素
删除:
public boolean removeElement ( Object obj) : 删除元素
获取功能:
public Object elementAt ( int index) : 获取指定位置的元素 -- -- -- > 类似于
public Object get ( int index)
Vector 集合的专有遍历方式
public Enumeration < E > elements ( ) : -- > 类似于Iterator literator ( )
boolean hasMoreElements ( ) : 判断是否有更多的元素可以迭代
Object nextElement ( ) 获取元素
Collection
List 最具体的子实现类ArrayList , LinkedList , Vector
List 集合有三个子实现类
1 ) . ArrayList
底层数据结构式数组结构, 查询快, 增删慢
从内存角度考虑: 线程不安全的, 不同步的, 执行效率高
多线程: synchronized : 同步的意思, 解决线程安全问题
sychronized ( 锁对象) { 同步代码
共享数据;
}
解决线程安全问题, 通过同步可以解决, 效率低了
2 ) . LinkedList
底层数据结构式链表结构, 查询慢, 增删快
从内存角度考虑: 线程不安全, 不同步, 执行效率高
3 ) . Vector
一个线程安全的类, 底层数据结构是数组, 查询快, 增删慢, 线程安全的, 同步, 执行效率低
核心思想: 使用1 角标对应的元素进行和0 角标对比, 如果前面元素大, 向右移动, 确定角标1 对应的元素位置, 再次使用2 角标对应的元素依次和1 和0 的元素比较, 依次这样比较. . .
Integer 类: 包含了int 类型的值 , Integer 实现了自然排序( 默认升序排序)
public class InsertSortDemo {
public static void main ( String [ ] args) {
Integer [ ] arr = { 65 , 34 , 78 , 13 , 3 , 26 } ;
System . out. println ( "排序前:" ) ;
printArr ( arr) ;
insertSort ( arr) ;
System . out. println ( "排序后:" ) ;
printArr ( arr) ;
}
public static void printArr ( Integer [ ] arr) {
System . out. print ( "[" ) ;
for ( int x = 0 ; x < arr. length; x++ ) {
if ( x== arr. length- 1 ) {
System . out. println ( arr[ x] + "]" ) ;
} else {
System . out. print ( arr[ x] + ", " ) ;
}
}
}
private static void insertSort ( Integer [ ] arr) {
int j;
for ( int y = 1 ; y< arr. length; y++ ) {
Integer temp = arr[ y] ;
for ( j = y; j > 0 && temp. compareTo ( arr[ j - 1 ] ) < 0 ; j-- ) {
arr[ j] = arr[ j - 1 ] ;
}
arr[ j] = temp;
}
}
}
1282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
