目录
2、 局部内部类访问局部变量的时候,此时局部变量应该注意什么?
8、方法的返回值是接口类型，需要返回的当前接口的子实现类对象
一、StringBuffer、StringBuilder的区别
三、StringBuffer,StringBuilder和String的区别?
七、String类的字符串反转，判断字符串是否为对称字符串（reverse）
三、public static Calendar getInstance()：静态功能，返回值是它自己本身
2、Collection的迭代器,Iterator iterator()
3、Object get(int index):获取指定位置处的元素 + int size():一种新的集合遍历方式
4、ListIterator listIterator():列表迭代器 :List集合专有遍历方式
四、java.util.ConcurrentModificationException:并发修改异常
内部类
一、局部内部类
1、什么是局部内部类
1、在外部类的成员方法中定义的类
2、局部内部类可以访问外部类的成员变量包括私有
3、在外部类的局部位置,访问内部类的成员方法,创建当前局部内部类对象来访问
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();
}
}
2、 局部内部类访问局部变量的时候,此时局部变量应该注意什么?
1、 如何此时Java环境是Jdk7，局部内部类访问局部变量时，此时该变量必须显示加入final修饰
2、为什么要加入final关键字呢？
局部变量的生命周期是随着方法调用而存在，随着方法调用结束而消失 ， 而当前外部类对象调用method 方法的时候。此时num进入栈内存，在局部位置创建了局部内部类对象 ，而局部内部类对象调用它的成员方法访问该变量，方法method方法结束之后，内部类对象不会立即消失， 它里面的成员方法在访问局部变量，局部变量必须变成常量，常驻内存，否则如果当前变量消失了，局部内部类的成员依然在访问，就会出现冲突。所以 jdk7 收到必须加入final修饰，jdk8通过jvm已经做了优化了，无需手动加入final修饰
二、匿名内部类
1、什么是匿名内部类
没有名字的内部类
2、使用位置
一般在局部位置使用·
3、格式
new 类名（可以是抽象类，也可以是具体类）或接口名（）{
重写功能
}；
4、本质
继承了该类或者是实现了该接口的子实现对象
5、举例
//定义一个接口
interface Inter{
void show() ;
void show2() ;
}
//为部类
class Outer3{
//定义一个成员方法
public void method(){
//优化:给匿名内部类起一个名字
Inter i = new Inter(){
@Override
public void show() {
System.out.println("show Inter...");
}
@Override
public void show2() {
System.out.println("show2 Inter...");
}
};
i.show();
i.show2();
}
}
//测试类
public class OuterDemo3 {
public static void main(String[] args) {
//创建Outer3类对象
Outer3 outer3 = new Outer3() ;
outer3.method();
}
}6、方法的形式参数如果是一个抽象类
（1）将子类定义出来，继承自抽象类
（2）直接使用抽象类的匿名内部类
//抽象类
abstract class Person{
public abstract void work();
}
//PersonDemo类
class PersonDemo{
public void method(Person p){
p.work();
}
}
//定义一个子类继承自Person类
class Student extends Person{
@Override
public void work() {
System.out.println("good good study ,day day up!!");
}
}
//测试类
public class PersonTest {
public static void main(String[] args) {
//创建PersonDemo类对象 /或者匿名对象
PersonDemo pd = new PersonDemo() ;
//抽象类多态:创建子类对象
Person p = new Student() ; //定义一个子类Student
pd.method(p) ;
//匿名内部类
PersonDemo pd1 = new PersonDemo() ;
pd1.method(new person(){
@Override
public void work() {
System.out.println("good good Study,day day Up!!");
}
});
}
}7、方法的形式参数是一个接口
（1）将接口的子实现类定义出来
（2）使用接口的匿名内部类
//定义一个结婚的接口
interface Mary{
void mary() ;
}
//定义一个LoveDemo类
class LoveDemo{
public void funciton(Mary mary){//形式参数是一个接口
mary.mary();
}
}
//定义一个子类实现类
class You implements Mary{
@Override
public void mary() {
System.out.println("要结婚了,很开心...");
}
}
public class LoveTest {
public static void main(String[] args) {
//方式1:需要调用LoveDemo类中的function方法
LoveDemo loveDemo = new LoveDemo() ; //或者使用匿名对象
//接口多态
Mary mary = new You() ;
loveDemo.funciton(mary);
//方式2:接口的匿名内部类
//创建LoveDemo类对象
LoveDemo ld = new LoveDemo() ;
ld.funciton(new Mary() {
@Override
public void mary() {
System.out.println("要结婚了,很开心...");
}
});
}
}8、方法的返回值是接口类型，需要返回的当前接口的子实现类对象
interface Love{
void love() ;
}
class LoveDemo{
public Love function(){
//匿名对象
return new Love(){
@Override
public void love() {
System.out.println("爱Java,爱学习...");
}
} ;
}
}
//定义接口的子实现类
class Student implements Love{
@Override
public void love() {
System.out.println("爱Java,爱学习...");
}
}
//测试类
public class LoveTest {
public static void main(String[] args) {
//要访问LoveDemo类中的function方法
LoveDemo ld = new LoveDemo() ;
Love love = ld.function();
love.love();
System.out.println("------------------");
//方式2:接口匿名内部类的方式
LoveDemo ld2 = new LoveDemo() ;
Love l = ld2.function();
l.love();
}
}9、方法的返回值是一个抽象类，需要返回当前抽象类的子类对象
abstract class Person{
public abstract void work() ;
}
class PersonDemo{
public Person method(){
//直接抽象类的匿名内部类
return new Person(){//相当于Person类的子类对象(匿名内部类的本质)
@Override
public void work() {
System.out.println("程序员日日夜夜敲代码");
}
} ;
}
}
//定义一个子类
class Programmer extends Person{
@Override
public void work() {
System.out.println("程序员日日夜夜敲代码...");
}
}
//测试类
public class PersonTest {
public static void main(String[] args) {
//调用PersonDemo类中的method 方法
PersonDemo pd = new PersonDemo() ;
Person person = pd.method(); //Person pserson = new Programmer() ;
person.work();
System.out.println("--------------------------");
//方式2:匿名内部类
PersonDemo pd2 = new PersonDemo() ;
Person p = pd2.method();
p.work();
}
}
Object
一、Object
java.lang.Object：
是类结构层次的根类(超类--->父类),所有的类都默认继承自Object子类(派生类)
二、 getClass()
public final Class getClass()：表示正在运行的类 (就是字节码文件对象)
三、getName()
获取当前类的全限定名称(包名.类名)
四、hashCode()
public int hashCode():获取对象的一个哈希码值 (本质不是地址值,可以把它理解为地址值)----跟哈希表有关系(HashMap)，一般情况:不同的对象获取的哈希码值是不同的 ,(但是中文字符,可能内容不一样,但是哈希码值不同!)，底层是通过哈希表算出来的,目前先了解!
五、 获取一个类的字节码文件对象有几种方式
第一种:通过Object类的getClass()--->Class :正在运行的java类: class 包名.类名
Student s = new Student() ;
Class c1 = s.getClass();
System.out.println(c1);//例class com.qf.generator_class_05.Student第二种:任意Java类型的class属性----获取当前类的字节码文件对象Class
Class c4 = Student.class ;
System.out.println(c4);//class com.qf.generator_class_05.Student第三种方式:Class里面forName("类的全限定名称(包名.类名)")
Class c3 = Class.forName("com.qf.generator_class_05.Student");
System.out.println(c1==c3);
六、toString()
1、返回对象的字符串表示形式。结果应该是一个简明扼要的表达，容易让人阅读。所有子类覆盖此方法。
2、描述一个对象:是由很多属性(成员变量组成),应该看到的具体的属性描述，大部分的常用类或者后面的集合都会重写Object类的toString()
七、 equals和==的区别
==：
==: 连接的基本数据类型:比较的是数据值否相同
==: 连接的是引用类型,比较的是地址值是否相同equals： 比较的是成员信息内容是否相同; 重写Object的equals方法同时还需要重写hashCode 内容相同,还需要比较哈希码值相同
重写：
alt+ins--->hashcode+equals方法
重写之后,就比较的是成员信息的内容是否相同!
八、clone克隆
protected Object clone() throws CloneNotSupportedException:创建对象并返回该对象的副本，这个方法会抛出一个异常，throws:表示的是可能出现异常,针对调用者必须进行处理
Scanner
类提供判断功能:防止出现输入的类型和结果类型不匹配
public boolean hasNextXXX():判断下一个录入的是否为指定的XXX类型
XXX nextXXX() 获取功能
public class ScannerDemo {
public static void main(String[] args) {
//创建键盘录入对象
InputStream inputStream = System.in ;
Scanner sc = new Scanner(inputStream) ;
System.out.println("请您输入一个数据:");
if(sc.hasNextInt()){
int num = sc.nextInt() ;
System.out.println("您录入的数据是:"+num);
}else if(sc.hasNextLine()){
//录入的字符串
String line = sc.nextLine() ;
System.out.println("您录入的数据是:"+line);
}else{
System.out.println("您录入的数据和结果类型不匹配...");
}
}
}String
一、String类的特点是什么
String:字符串是一个常量,一旦被赋值,其值不能被更改;和StringBuffer最大区别:后者支持可变的字符序列,前者是一个不可变的字符序列
String str = "abc" ;
二、String构造方法
1、public String();//空参构造:空字符序列
String s = new String() ;
System.out.println("s:"+s); //String类重写了Object的toString(),
System.out.println(s.length());
2、public String(byte[] bytes);//将一个字节数组构造成一个字符串,使用平台默认的字符集(utf-8:一个中文对应三个字节) 解码
byte[] bytes = {97,98,99,100,101} ;
String s2 = new String(bytes) ;
System.out.println(s2);
3、public String(byte[] bytes,字符集);//使用指定的字符集,将字节数组构造成一个字符串
4、public String(byte[] bytes,int offset,int length);//将指定的部分字节数组转换成字符串
//参数1:字节数组对象,参数2:指定的角标值 参数3:指定长度
String s3 = new String(bytes,2,2) ;
System.out.println(s3);
System.out.println(s3.length());5、public String(char[] value);将字符数组构造成一字符串
char[] chs = {'我','爱','高','圆','圆'} ;
String s4 = new String(chs) ;
System.out.println(s4);
System.out.println(s4.length());6、public String(char[] value,int offset,int count);将部分字符数组转换成字符串
String s5 = new String(chs,1,4) ;
System.out.println(s5);
System.out.println(s5.length());7、public String(String original);构造一个字符串,参数为字符串常量
String s6 = new String("hello") ; //创建字符串对象,常量值:hello
System.out.println(s6);
String s7 = "hello" ; //推荐的方式
System.out.println(s7)三、String类型常用的转换功能
1、byte[] getBytes()；将字符串转换成字节数组 (编码)，如果方法为空参,使用平台默认的编码集进行编码
String str = "中国" ;
byte[] bytes = str.getBytes();//默认utf-8
System.out.println(Arrays.toString(bytes));//[-28, -72, -83, -27, -101, -67]2、 byte[] getBytes(String charset):-----------使用指定的字符集进行编码
3、String(byte[] bytes):-----------------------------使用默认字符集进行解码
String strResult = new String(bytes) ;// //使用平台默认解码集进行解码: utf-8
System.out.println(strResult);4、 String(byte[] bytes,-----------------------------指定字符集
5、public char[] toCharArray():------------------将字符串转换成字符数组
//定义一个字符串
String s2 = "helloworldJavaEE" ;
// public char[] toCharArray()
char[] chs = s2.toCharArray();
//遍历字符数组
for(int x = 0 ; x < chs.length; x ++){
System.out.println(chs[x]);
}6、 public String toString():-----------------------返回自己本身---"当前字符串的内容"
System.out.println(s2.toString());7、 public String toUpperCase():--------------将字符串转换成大写
8、 public String toLowerCase():-----------------将字符串转换成小写
System.out.println(s2.toUpperCase());
System.out.println(s2.toLowerCase());四、 String类型的判断功能
1、public boolean equals(Object anObject)://比较两个字符的内容是否相同 (区分大小写)
2、public boolean equalsIgnoreCase(String anotherString)://比较两个字符串是否相同(不区分大小写)
3、public boolean startsWith(String prefix)://判断字符串是否以指定的内容开头
4、public boolean endsWith(String suffix)://判断字符串是否以指定的内容结尾
5、boolean isEmpty() //判断字符串是否为空 :若为空,则返回true;否则返回false
6、String s = "" ;// 空字符串 ,存在String对象 ""
7、String s = null ; //空值 (空对象) null:引用类型的默认值
例：
String s1 = "helloJavaEE" ;
String s2 = "hellojavaee" ;
//比较两个字符的内容是否相同 (区分大小写)
System.out.println("equals:"+s1.equals(s2));
//比较两个字符的内容是否相同 (不区分大小写)
System.out.println("equalsIgnoreCase():"+s1.equalsIgnoreCase(s2));
/*
* public boolean startsWith(String prefix):判断字符串是否以指定的内容开头
* public boolean endsWith(String suffix):判断字符串是否以指定的内容结尾
* boolean isEmpty() 判断字符串是否为空 :若为空,则返回true;否则返回false
*/
System.out.println("startsWith():"+s1.startsWith("hel"));
System.out.println("startsWith():"+s1.startsWith("ak47"));
System.out.println("endsWith():"+s1.endsWith("EE"));
s1 = "" ; //length()---->长度0 (空字符序列)
System.out.println(s1.isEmpty());五、 String类的获取功能
1、int length():获取字符串长度
2、 public char charAt(int index);获取指定索引处的字符
String str = "helloworldJavaEE" ;
System.out.println("charAt():"+str.charAt(4));3、 public String concat(String str):将指定的字符串和当前字符串进行拼接,获取一个新的字符串
System.out.println("concat:"+str.concat("R").concat("Go"));4、public int indexOf(int ch):返回指定字符第一次出现的索引值
5、public int lastIndexOf(int ch):返回值指定字符最后一次出现的索引值
System.out.println("indexOf():"+str.indexOf("o"));
System.out.println("lastIndexOf():"+str.lastIndexOf("o"));6、 public String[] split(String regex): 拆分功能:通过指定的格式将字符串---拆分字符串数组
String str2 = "JavaEE-Python-Go-R-C-C#-PHP" ;
String[] strArray = str2.split("-");
for(int x = 0 ; x < strArray.length ; x ++){
System.out.print(strArray[x]+"\t");
}7、public String substring(int beginIndex) :从指定位置开始默认截取到末尾角标从0开始
8、public String substring(int beginIndex,int endIndex)； 从指定位置开始,截取到位置结束(包前不包右)，只能取到endIndex-1处
String str = "helloworldJavaEE" ;
System.out.println("subString():"+str.substring(5));
System.out.println("subString():"+str.substring(5,9))9、 public static String valueOf(boolean/int/long/float/double/char...Object b)； 万能方法,将任意类型转换String类型
System.out.println("valueOf:"+String.valueOf(100))10、 public String replace(char target,char replacement) 将指定的内容使用target字符进行替换
String s = "helloworld" ;
System.out.println("replace():"+s.replace('l','k'));11、public String trim():去除字符串两端的空格
String s3 = " hello " ;
System.out.println("s3:"+s3.trim()+"----");12、 public int compareTo(String anotherString):按照字典顺序比较,返回值是int
String s1 = "hello" ;
String s2 = "hel" ;
String s3 = "abc" ;
s1.compareTo(s2); //2
s1.compareTo(s3) ;//7
String类型---内置一个属性: char[] value
//1)字符串底层---->字符数组 s1和s2--->转换字符串数组 获取长度 5 和 3
2)通过Math的main方法(5,3) --->获取最小值 int lim = 3 ;
3) 创建两个数组对象 char[] c1 = {'h','e','l','l','o'}
char[] c2 = {'h','e','l'} ;
4)判断 定义统计变量 k = 0
while(k < lim){
if(c1[k] != c2[k]){
return 对应的字符值进行相减
return 'h' - 'a' = 104 - 97 = 7
}
k ++ ; //统计变量++
}
return 字符串的长度相减(字符数组长度相减)
六、int和String类型之间如何转换
//int---->String
//integer类型的静态功能toString
public static String toString(int i)
//String--->int
//Integer的静态功能
public static int parseInt(String s)
//String ---->Integer ---->int
String s = "100" ;
Integer i = new Integer(s) ;
int num = i.intValue() ;七、面试题
1、在数组中有没有length方法,在String类中有没有length方法,在集合中有没有length方法
数组中没有length方法,length属性
int[] arr = new int[3] ;
arr.length;
String类中有length();
集合中没有length(),----->size()获取元素数
2、 String s1 = "hello" ; String s2 = new String("hello") ;在内存中分别创建了几个对象?
第一个创建了一个对象,直接在常量池创建,开辟常量池空间
第二个创建了两个对象,一个堆内存中开辟空间,一个指向常量池(不推荐)
3、 == 和equals
== :连接引用类型比较的是地址值
equals:默认比较地址值,但是String类重写equals方法,所以内容是否相同
StringBuffer
一、StringBuffer、StringBuilder的区别
共同点:
两个都都是字符串缓冲区,支持可变的字符序列!
不同点:
StringBuffer:线程安全的类---->同步的(多线程:同步锁:源码几乎所有的方法都是同步方法 synchronized)执行效率低
StringBuilder:线程不安全的类---->不同步----->执行效率高
单线程程序中,只考虑执行效率不考虑安全,所以StringBuilder类用作StringBuffer的简易替换
多线程环境中,要考虑安全问题只能使用StringBuffer,
线程安全的类:StringBuffer,Vector(List接口的子类)
二、StringBuffer和数组的区别
共同点:都是容器,都可以存储任意类型的元素 , 可以存储基本类型,也可以存储引用类型
数组---->同一种类型的元素 长度是固定的
如果需求中长度是不断变化的,那么数组用不了,考虑:StringBuffer/集合StringBuffer---->存储不同类型的元素 append(int/char/double/Object/foat...) 长度是可变的
借助StringBuffer的功能:reverse()/append()追加----->转换成String形式体现
三、StringBuffer,StringBuilder和String的区别?
String:字符串是一个常量,一旦被赋值,其值不能更改/作为形式参数属于特殊的引用类型,形式参数的改变不会实际参数
StringBuffer:可变的字符序列,线程安全的类----同步的----->执行效率低(线程角度)
StringBuilder:可变的字符序列.和StringBuffer具有相互兼容的api,单线程程序中(只考虑执行效率,不考虑安全问题)会使用StringBuilder替代StringBuffer
作为方法的形式参数,形参的改变会直接影响实际参数
四、 StringBuffer的构造方法
1、public StringBuffer() ://空参构造,创建一个空字符序列的字符串缓冲去 (推荐)
2、public StringBuffer(int capacity)://构造一个字符串缓冲区对象,指定容量大小
3、public StringBuffer(String str)://指定字符序列,长度加上初始容量16(总容量)
StringBuffer sb3 = new StringBuffer("hello") ; //'h','e','l','l','o'
System.out.println("sb3:"+sb3);
System.out.println(sb3.length());
System.out.println(sb3.capacity());五、 StringBuffer的常用功能
StringBuffer的反转功能：reverse()
StringBuffer的追加功能：append(xxx)
StringBuffer的删除工能：deleteCharAt(int index)、delete(int start,int end)
StringBuffer的截取功能：subString(int bengin,int end)
StringBuffer的截取功能：subString(int bengin）
StringBuffer的插入功能：insert(int offset,String str）
六、 String类的遍历
//将字符串的每一个字符分别输出! charAt(int index)
String str = "helloJavaEE" ;
//循环改进: 利用String类的length():获取字符串长度 + charAt(int index)
for(int x = 0 ;x < str.length() ; x ++){
System.out.println(str.charAt(x));//charAt(0)
}
//使用String类的转换功能
//String---->字符数组toCharArray()--->char[]
char[] chs = str.toCharArray();
for(int x = 0 ; x < chs.length ; x ++){
char ch = chs[x] ;
System.out.println(ch);
}七、String类的字符串反转，判断字符串是否为对称字符串（reverse）
public class StringTest4 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个字符串:");
String line = sc.nextLine() ;
//方式2:使用StringBuffer的功能改进
boolean flag2 = compare2(line) ;
System.out.println(flag2);
private static boolean compare2(String line) {
/*
StringBuffer sb = new StringBuffer(line) ;
String str = sb.reverse().toString();
return str.equals(line) ;
*/
return new StringBuffer(line).reverse().toString().equals(line) ;
}
}
}八、String类的equals方法表示什么意思
String类底层已经针对Object的equals和hashCode方法进行了重写
hashCode():String对象的哈希码值是否相同,哈希码值相同的不一定内容就相同,所以它需要覆盖equals方法
比较的字符串内容是否相同.：
String s1 = "hello" ;
String s2 = new String("hello") ;
s1 ==s2---> false
s1.equals(s2) ---->true九、StringBuffer和String如何转换
//String--->StringBuffer
String s = "hello" ;
//使用StringBuffer的有参构造方法
StringBuffer sb = new StringBuffer(s)
//或者是StringBuffer的追加功能
StringBuffer sb = new StringBuffer() ;
sb.append(s) ;
//StringBuffer--->String
//String类的构造方法 String(StringBuffer)
StringBuffer buffe = new StringBuffer("world") ;
String str = new String(buffer) ;
//第二种方式:StringBuffer的toString方法Integer
一、基本类型对应的包装类类型
整数类型 引用类型(默认值都是null)
byte Byte
short Short
int Integer
long Long
浮点类型
float Float
double Double
字符类型
char Character
布尔类型
boolean Boolean
二、通过Integer得到int类型的取值范围
1、public static String toBinaryString(int i)://将整数---->二进制 的字符串
2、public static String toOctalString(int i)://将整数---->八进制的字符串
3、public static String toHexString(int i)://将整数---->十六进制数据
4、public static final int MAX_VALUE:int的最大值
5、public static final int MIN_VALUE:int的最小值
System.out.println(Integer.toBinaryString(100)); // 1100100
System.out.println(Integer.toOctalString(100)); // 144
System.out.println(Integer.toHexString(100)); //64
System.out.println(Integer.MIN_VALUE);//-2的31次方
System.out.println(Integer.MAX_VALUE);//2的31次方-1三、Integer的构造方法
Integer(int value):可以将int类型保证为Integer类型
Integer(String s) throws NumberForamtException: 抛出一个数字格式化异常
注：当前字符串如果不是能够解析的整数的,就会出现数字格式化异常,s必须为 数字字符串
String s = "50" ;
Integer integer2 = new Integer(s) ;
System.out.println(integer2);四、自动拆装箱
基本类型---> 对应的包装类类型 (装箱)
对应的包装类型---->基本类型 (拆箱)
// 方式:int---->Integer---->String
int i = 50 ;
Integer ii = new Integer(i) ;
String str2 = ii.toString();
System.out.println(str2);//50
//方式:String ---->Integer---->int
String s = "100" ;
Integer integer = new Integer(s) ;
int result2 = integer.intValue();
System.out.println(result2);//100> Integer的内部缓存区：IntegerCache
取值范围： low =-128 high=127
直接赋值的形式----》执行的底层Integer.valueOf(int i){}
> Integer i = 128 ; //new Integer(128)
> Integer i2 =128 ; //new Integer(128)
> System.out.println(i == i2) ;false
char-类型的包装类类型
一、构造方法
public Character(char value)
//创建字符类对象
//Character character = new Character('a') ;
Character character = new Character((char)(97)) ;
System.out.println(character); ----------a二、主要功能
1、public static boolean isUpperCase(char ch)://判断当前字符是否大写字母字符
2、public static boolean isLowerCAse(char ch)://是否为小写字母字符
3、public static boolean isDigit(char ch)://是否为数字字符
三、举例
//定义三个统计变量
int bigCount = 0 ;
int smallCount = 0 ;
int numberCount = 0;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据:");
String line = sc.nextLine() ;
//转换成字符数组
char[] chs = line.toCharArray();
for (int i = 0; i <chs.length ; i++) {
char ch = chs[i] ;
//直接判断
if(Character.isDigit(ch)){
numberCount ++ ;
}else if(Character.isUpperCase(ch)){
bigCount ++ ;
}else if(Character.isLowerCase(ch)){
smallCount ++;
}
}Date-日历类
一、Date：当前系统时间格式
public Date()://当前系统时间格式
public Date(long date):参数为 时间毫秒值---->Date对象 (1970年1月1日...)
//创建日期类对象
Date date = new Date() ;
System.out.println(date);
long time = 60*60 ;
Date date2 = new Date(time) ;
System.out.println(date2);二、Date和String类型如何转换
//java.util.Date---->String： 格式化操作
//1)创建Date对象
Date date = new Date() ;
//2)创建SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;
//3)格式化的操作
String textDate = sdf.foramt(date) ; //使用textDate:日期文本字符串
//String：日期文本字符串----->java.util.Date :解析操作
//1)日期文本字符串
String source = "2021-7-29" ; //格式
//2)创建SimpleDateFormat对象
SimplDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ; //模式必须和String的格式一致,否则解析出错
//3)解析操作
Date date2 = sdf2.parse(source) ; //使用Date三、public static Calendar getInstance()：静态功能，返回值是它自己本身
public int get(int field)://根据给定日历字段----获取日历字段的值(系统的日历)
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR) ;
int month = calendar.get(Calendar.MONTH) ;
int date = calendar.get(Calendar.DATE) ;
public abstract void add(int field,int amount)://给指定的日历字段,添加或者减去时间偏移量
参数1:日历字段
参数2:偏移量
int year = calendar.add(Calendar.YEAR,-3);Math-计算
一、针对数学运算的工具类,提供了的方法
1、public static int abs(int a):绝对值方法
System.out.println(Math.abs(-100));-------//1002、public static double ceil(double a):向上取整
System.out.println(Math.ceil(13.56));-----//143、public static double floor(double a):向下取整
System.out.println(Math.floor(12.45));----//124、public static int max(int a,int b):获取最大值
System.out.println(Math.max(Math.max(10,30),50));//方法嵌套5、 public static double pow(double a,double b):a的b次幂
System.out.println(Math.pow(2,3));-------//2^36、 public static double random():[0.0,1.0):随机数
System.out.println(Math.random());7、 public static long round(d ouble a):四舍五入
System.out.println(Math.round(13.78));-----//148、 public static double sqrt(double a):开平方根
System.out.println(Math.sqrt(4));--------//2二、使用注意事项
1、JDK5的静态淡入特性，方法必须是静态的
2、Math类的功能都是静态的，就可以使用静态导入 // import static 包名.类名.方法名
3、不能和其他方法重名
Random-伪随机数生成器
一、构造方法
public Random()；//产生一个随机生成器对象，通过成员方法随机数每次没不一样的(推荐)
public Random(long seed)；//参数为long类型的值(随机数流:种子),每次通过成员方法获取随机数产生的随机数相同的
二、成员方法
public int nextInt()；//获取的值的范围是int类型的取值范围(-2的31次方到2的31次方-1)
public int nextInt(int n)；//获取的0-n之间的数据 (不包含n)
三、获取1-30之间10个随机数
public class RandomDemo {
public static void main(String[] args) {
Rendom rendom = new Rendom();
for(int i = 0;i<10;i++){
int num = (rendom.nextInt(30)+1);
System.out.println(num);
}
}
} BigDecimal-小数的精确计算
一、构造方法
public BigDecimal(String value)；//数字字符串
二、成员方法:
1、public BigDecimal add(BigDecimal augend);//加
2、public BigDecimal subtract(BigDecimal subtrahend);//减
3、public BigDecimal multiply(BigDecimal multiplicand);//乘
4、public BigDecimal divide(BigDecimal divisor);//除
5、public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode);
参数1:商
参数2:小数点后保留的有效位数
参数3:舍入模式 :四舍五入
三、数组计算
public class BigDecimalDemo {
public static void main(String[] args) {
//创建BigDecimal对象
BigDecimal bg1 = new BigDecimal("1.01") ;
BigDecimal bg2 = new BigDecimal("0.36") ;
System.out.println("------------------------------------");
BigDecimal bg3 = new BigDecimal("10.0") ;
BigDecimal bg4 = new BigDecimal("5.05") ;
System.out.println(bg1.add(bg2));----------1.37
System.out.println(bg1.subtract(bg2));-----0.65
System.out.println(bg1.multiply(bg2));-----0.3636
System.out.println(bg3.divide(bg4,3,BigDecimal.ROUND_HALF_UP));//四舍五入--1.980
}
}Collection-集合
压制警告
@SuppressWarnings("all") //jdk提供的内置注解:压制警告
一、集合和数组的区别
1、长度区别
数组：长度固定
集合：长度可变
2、存储数据类型
数组：可以存储基本数据类型，也可以存储引用数据类型
集合：只能存储引用数据类型
3、存储元素
数组：元素必须一致
集合：任意类型元素
二、Collection解释
Collection:集合层次的根接口,一些集合允许元素重复(List),一些集合不允许元素重复(Set)，一些集合有序(存储和取出一致)(List),一些集合无序(存储和取出不一致)(Set),JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List
三、List
最具体的子实现类ArrayList,LinkedList,Vector
四、基本功能
1、添加：
boolean add(Object e）；//添加元素 E(Element)
2、删除：
void clear() ；//暴力删除(将集合的素有元素全部干掉)
boolean remove(Object o)；//从集合中删除指定的元素
3、获取：
int size()；//获取集合的元素数
4、判断功能：
boolean isEmpty()；//判断集合是否为空,为空元素,则返回true
boolean contains(Object o)；//判断集合中是否包含指定元素,包含则返回true
public class CollectionDemo {
public static void main(String[] args) {
//创建Collection集合对象，接口多态
Collection c = new ArrayList();//ArrayList重写了Object的toString()方法
//添加元素
c.add("hello");
c.add(100);
c.add("java");
System.out.prinln(c);---// [hello, 100, java]
System.out.println(c.size());----//3
System.out.println(c.contains("world"));--//false
System.out.println(c.contains("java"));--//true
System.out.println(c.isEmpty()); --//false
System.out.println(c.remove(100));
System.out.println(c);---// [hello, java]
}
}五、高级功能
1、boolean addAll(Collection c)://添加一个集合中的所有元素--------------全部为空值为False
2、boolean containsAll(Collection c)://包含一个集合中的所有元素---------有一个没包含为False
3、boolean removeAll(Collection c)://删除集合中的所有元素, (删除一个算删除)
4、boolean retainAll(Collection c)://A集合对B集合求交集,交集的元素存储在A集合中,然后返回值的意思: 看A集合的元素是否有变化(之前的元素和现在交集的元素进行对比)，如果有变化,返回true;没有变化,则返回false
六、将集合转换成了对象数组
public class CollectionDemo2 {
public static void main(String[] args) {
//创建一个Collection集合对象
Collection c = new ArrayList() ;
//创建数值
Student s1 = new Student("宋江",45,"男") ;
//存储集合中
c.add(s1) ;
// Object[] toArray():将集合转换成了对象数组
Object[] objs = c.toArray();//数组存储的每一个数据类型 Object obj = new Student() ; //向上转型
//遍历数组
for(int x = 0 ; x < objs.length ; x ++){
Student student = (Student) objs[x]; //向下转型
System.out.println(student.getName()+"---"+student.getAge()+"---"+student.getGender());
}
}
}七、 Iterator-迭代器
/*
Collection的迭代器:集合的专有遍历方式
Iterator iterator():返回值类型接口类型,需要返回的子实现类对象
Iterator接口:
boolean hasNext():判断迭代器中是否存在下一个元素
Object next(): 获取下一个可以遍历的元素
给Collection中存储String类型,遍历出来
*/
public class CollectionTest2 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
Student s1 = new Student("诸葛亮",45) ;
c.add(s1) ;
//获取迭代器
Iterator iterator = c.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
Student s = (Student)obj ;
System.out.println(s.getName()+"---"+s.getAge());
}
}
} Iterator的原理是什么
Iterator的原理:
内部具备一个指针,当在第一次获取元素的时候,指针处在第一个元素前面的位置,不指向任何元素;当通过hasNext()判断,如果存在下一个可以迭代的元素,那么指针就会向下一个索引进行移动,并且next()获取前面的元素,依次这样操作,直到hasNext()为false的时候,没有元素了,指针就不会在移动;Iterator是一个接口,具体的移动的操作是通过ArrayList的成员内部类Itr来进行实现;
八、泛型
//格式：集合类型<引用数据类型> 集合对象名 = new 子实现类<引用数据类型>() ;
/*
泛型的好处:
1)将运行时期异常提前了编译时期
2)避免了强制类型转换
3)提高了程序安全性
*/
public class GenericDemo {
public static void main(String[] args) {
//创建Collection集合对象
Collection<String> c = new ArrayList<String>() ;
c.add("hello") ;
//获取迭代器Iteratr<E>是集合中存储的泛型是一致的
Iterator<String> it = c.iterator();
while(it.hasNext()){
//获取String字符串的同时,还要获取长度
String str = it.next();
System.out.println(str+"---"+str.length());
}
}
}List
一、List接口的特点
1、继承Collection，具备Collection相关功能
Object [] toArray()
Iterator iterator()
2、有序（存储元素和取出元素一致）
3、允许元素重复
二、特有功能
1、void add(int index,Object element);//在制定索引处插入元素
2、Object get（int index）;//获取制定位置出的元素
3、Object remove(int index)；//删除指定位置处的元素，返回被删除的元素
4、Object set(int index,E element)；//修改指定位置处的元素(替换)
ListIterator<E> listIterator(); //列表迭代器
ListIterator接口：
void add（E e ） //有添加
remove（） //有删除
public class ListDemo {
public static void main(String[] args) {
//创建List集合对象
List<String> list = new ArrayList<String >();
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("world") ;
list.add("javaEE") ;
// void add(int index,Object element):在指定的索引处插 入元素
list.add(1,"高圆圆");
System.out.println(list);//--[hello,高圆圆,world,world,javaEE]
//Object get(int index):获取指定位置处的元素 :返回的被获取到的元素内容
System.out.println(list.get(1));//--world
// Object remove(int index):删除指定位置处的元素,返回被删除的元素
System.out.println(list.remove(2));//--world
//Object set(int index,E element):修改指定位置处的元素(替换)
System.out.println(list.set(0,"赵又廷"));//--hello
}
}三、Lise集合的遍历方式
1、Object[] toArray()
public class ListTest1{
public static void mian(String[] args){
//创建List集合对象
List<Student> list = new ArrayList<Student>();
//添加元素
Student s1 = new Student("张佳宁",31) ;
Student s2 = new Student("迪丽热巴",29) ;
Student s3 = new Student("张俊杰",20) ;
//添加到列表
stuList.add(s1) ;
stuList.add(s2) ;
stuList.add(s3) ;
//遍历
Object[] obj = list.toArray();
for(int x = 0; x < obj.length; x++){
Student s = (Student) obj[x];//向下转型
System.out.println(s.getName()+s.getAge());
}
}
}
2、Collection的迭代器,Iterator iterator()
//Collection的迭代器
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s.getName+s.getAge);
}3、Object get(int index):获取指定位置处的元素 + int size():一种新的集合遍历方式
public class ListTest1{
public static void mian(String[] args){
//创建List集合对象
List<Student> list = new ArrayList<Student>();
//添加元素
Student s1 = new Student("张佳宁",31) ;
Student s2 = new Student("迪丽热巴",29) ;
Student s3 = new Student("张俊杰",20) ;
//添加到列表
stuList.add(s1) ;
stuList.add(s2) ;
stuList.add(s3) ;
//size()+get(int index)
for(int x = 0 ; x < list.size() ; x ++){
Student s = list.get(x);
System.out.println(s.getName()+"----"+s.getAge());
}
}
}4、ListIterator<E> listIterator():列表迭代器 :List集合专有遍历方式
//正向遍历:ListIterator<E> listIterator():列表迭代器
ListIterator<Student> lit = list.listIterator();
while(lit.hasNext){
Student student = lit.next();
System.out.println(student.getName+student.getAge);
}
//逆向遍历:前提:必须有正向遍历
while(lit.hasPrevious()){
Student stu = lit.previous();
System.out.println(stu.getName+stu.getAge);
}四、java.util.ConcurrentModificationException:并发修改异常
1、什么是并发修改异常
集合在使用迭代器会经常出现的问题:并发修改异常；当集合的元素正在被迭代器进行遍历,那么集合对象是不能够对元素进行增加或者删除 (一个线程正在遍历,一个线程在修改元素)
2、解决方案
1)迭代器去遍历集合的元素,迭代器去添加元素 :列表迭代器才具备添加的动作
2)要么集合遍历,集合添加
/*通过List集合ArrayList集合对象,如果当前集合中存在"world"元素,那么就给集合中添加一个"javaEE"元素,最后将集合中的所有元素进行遍历!
List集合现在就存有三个元素："hello"，"world"，"java" */
public class ListTest2 {
public static void main(String[] args) {
//创建List集合对象
List<String> list = new ArrayList<>() ;
//给添加元素
list.add("hello") ;
list.add("world") ;
list.add("javaee") ;
//解决方案1: 迭代器去遍历集合的元素,迭代器去添加元素:列表迭代器才具备添加的动作
ListIterator<String> lit = list.ArratList<>();
while(lit.hasNext()){
String s = lit.next();
//判断元素是否存在"word"
if("world".equals(s)){
//列表添加迭代器
lit.add("javaEE");
}
}
//方案2:集合遍历,集合添加
for(int i = 0;i < list.size();x++){
String s = list.get(x);
if("world".equals(s)){//将常量放前面,防止出现NullPointerException
list.add("javaEE");
}
}
System.out.println(list);
}
}五、增强for循环
1、什么是增强for循环
JDK5以后 提供了增强for循环,替代集合中迭代器去遍历集合使用的(优先在集合中使用)
2、格式
for(存储的引用数据类型 变量名: 集合/数组对象){ //集合使用居多,数组一般都是使用普通for
使用变量名即可
}
3、List集合和Set集合特点
List集合有序,存储和取出一致的,可以允许元素重复
Set集合无序,存储和取出不一致,不允许元素重复(元素唯一)
每一个子实现类的特点: 通过API后面分析
4、注意事项
当前集合对象不能为空 null :foreach语句:增强for它本身就是获取迭代器了,就会出现空指针异常
例：使用增强for遍历List<Student>,存储三个学生,遍历后获取学生信息(姓名和年龄)
public class StudentText{
public static void main(String[] args){
//创建List对象
List<String> list = new ArrayList<String>();
//创建学生对象
Student s1 = new Student("张佳宁",29) ;
Student s2 = new Student("邓超",40) ;
Student s3 = new Student("黄海波",30) ;
list.add(s1) ;
list.add(s2) ;
list.add(s3) ;
//增强for循环
for(Student s : list){
System.out.println(s.getName()+"---"+s.getAge());
//张佳宁---29
//邓超---40
//黄海波---30
System.out.println(s); //对象名称:直接使用重写后的toString()
// Student{name='张佳宁', age=29}
//Student{name='邓超', age=40}
//Student{name='黄海波', age=30}
}
}
}六、List集合如何去重
1、新建空集合思想---存储字符串类型并保证集合的元素唯一
public class ListTest{
public static void main(String[] args){
//创建List集合
List<String> list = new ArrayList();
//添加元素
list.add("hello") ;
list.add("hello") ;
list.add("world") ;
list.add("world") ;
list.add("javaEE") ;
list.add("javaEE") ;
list.add("android") ;
list.add("android") ;
list.add("ios") ;
//新建一个空集合
List<String> newlist = new ArratList();
//遍历以前的集合
for(String s :list){
//判断元素是否重复
if(!newlist.contain(s)){
newlist.add(s);
}
}
//遍历新集合
for(String s :newlist){
System.out.println(s);
}
}
}2、利用选择排序的思想去完成
public class ListTest3 {
public static void main(String[] args) {
//创建List集合
List<String> list = new ArrayList<>() ;
//现在给集合中添加重复的字符串数据
list.add("hello") ;
list.add("hello") ;
list.add("world") ;
list.add("world") ;
list.add("javaEE") ;
list.add("world") ;
list.add("javaEE") ;
list.add("android") ;
list.add("android") ;
list.add("ios") ;
//利用选择排序的思想完成
for(int x = 0 ; x < list.size()-1 ; x ++){
for(int y = x +1 ; y < list.size() ; y++){
//如果后面的元素和前面的元素相同
if(list.get(y).equals(list.get(x))){
//通过集合remove掉
list.remove(y) ; // public Object remove(int index)
//角标--
y -- ;
}
}
}
for(String s:list){
System.out.println(s);
}
}
}3、存储自定义对象如何去重
public class ListTest4 {
public static void main(String[] args) {
//创建一个List集合
List<Student> list = new ArrayList<>();
//创建一些学生对象:有重复的成员信息
Student s1 = new Student("高圆圆", 42);
Student s4 = new Student("高圆圆", 42);
Student s3 = new Student("刘诗诗", 39);
Student s2 = new Student("刘诗诗", 39);
Student s5 = new Student("张佳宁", 30);
Student s6 = new Student("文章", 36);
Student s7 = new Student("文章", 36);
Student s8 = new Student("姚笛", 32);
//添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
list.add(s7);
list.add(s8);
//1、创建新集合
List <Student> newList = new ArrayList<>();
//遍历之前的集合，获取每一个学生的对象
for(Student s : list){
//如果当前newList集合不包含这个学生就添加
if(!newList.contains(s)){
newList.add(s);
}
}
//遍历新集合
for(Student s :newList){
System.out.println(s.getName()+s.getAge());
}
//2、选择排序
for(int i = 0;i<list.size()-1;i++){
for(int j = i+1;j<list.size();j++){
if(list.get(j).equals(list.get(i))){
j--;
}
}
}
//遍历
for(Student s : list){
System.out.println(s.getName()+s.getAge());
}
}
}Vector
一、特有功能
1、添加
public void addElement(Object obj):在vector对象的末尾添加元素
2、删除
public boolean removeElement(Object obj):删除元素
3、获取
public Object elementAt(int index):获取指定位置的元素
public Enumeration<E> elements() :Vector集合的专有遍历方式
4、接口
boolean hasMoreElements():判断是否有更多的元素可以迭代
5、获取元素
Object nextElement() 获取元素
二、特有的遍历功能
public class VectorDemo {
public static void main(String[] args) {
//创建Vector集合对象
Vector<String> v = new Vector<>() ;
v.addElement("hello");
v.addElement("world");
v.addElement("SpringBoot");
v.addElement("SpringCloud") ;
//遍历:特有功能
Enumeration<String> en = v.elements(); //相当于Iterator
//获取元素
while(en.hasMoreElements()){
String s = en.nextElement();
System.out.println(s+"---"+s.length());
}
System.out.println("----------------------------------");
//遍历
for(String s: v){
System.out.println(s+"----"+s.length());
}
}
}三、List集合三个子实现类的特点
ArrayList
底层数据结构是数组,查询快,增删慢
Vector集合
底层数据结构是数组,查询快,增删慢
线程角度:线程安全的类----同步的方法---->执行效率低
单线程程序中.考虑集合默认都会使用 ArrayList,多线程环境集合---->Vector集合
LinkedList
底层数据结构是链表,查询慢,增删快
线程角度:线程不安全的类---->不同步---->执行效率高
插入排序
核心思想
使用1角标对应的元素进行和0角标比较，如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较
/*
核心思想
使用1角标对应的元素进行和0角标比较，如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较
*/
public class InsertSortTest {
public static void main(String[] args) {
//定义一个Integer数组: Integer实现的自然排序:元素能够按照升序默认排序
Integer[] arr = {34,8,64,51,32,21} ;
System.out.println("排序前:");
printArr(arr);
//定义一个功能
insertSort(arr) ;
System.out.println("排序后:");
printArr(arr);
}
//插入排序
private static void insertSort(Integer[] arr) {
//定义一个变量j
int j ; //j记录当前角标的变化
//定义变量 : p:表示一个比较次数 p=1,2,3,4,5 (每一移动的元素的位置)
for(int p = 1 ; p < arr.length ; p ++ ){ //比较次数
//定义临时变量temp
Integer temp = arr[p] ;
//开始比较
for(j = p ; j>0 && temp.compareTo(arr[j-1])<0; j-- ){
//数据移动
arr[j] = arr[j-1] ;
}
arr[j] = temp ;
}
}
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]+", ");
}
}
}
}
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
