20.内部类

1.格式

内部类:在一个类中可以定义另一个:在类A 中定义了类B,将类B就称为类A的内部类,类A就是外部类!
成员内部类:在一个类的成员位置中定义了另一个类内部类可以访问外部类的成员,包括私有!

//外部类
class Outer{//成员变量public int num = 100 ;private int num2 = 200 ;class Inner{ //成员内部类//成员内部类的一个成员方法public void method(){System.out.println("method Inner");System.out.println();System.out.println(num2);}}//外部类的成员方法public void show(){//访问的成员内部类的method--->通过创建内部类对象来访问//method() ;错误的----访问的本类的method方法Inner inner = new Inner() ;inner.method();}
}
//测试
public class InnerClassDemo {public static void main(String[] args) {//创建外部类对象Outer outer = new Outer() ;outer.show();}
}

2.外部类访问内部类

1）外部类如何直接访问内部类的成员方法?格式:外部类名.内部类名  对象名 =  new 外部类对象().new 内部类对象() ;

class Outer2{private int num = 20 ;//成员内部类class Inner2{public void show(){System.out.println(num);}}//外部类的成员方法public void method(){// 创建内部类对象访问内部类的成员方法}
}
//测试类
public class InnerClassDemo2 {public static void main(String[] args) {//外部类名.内部类名  对象名 =  外部类对象.内部类对象;//适用于:通过外部类直接访问成员内部类的成员(前提条件:当前成员内部类是一个非静态类)Outer2.Inner2 oi = new Outer2().new Inner2() ;oi.show() ;}
}

2）关于我们成员内部类的修饰符:在成员内部类上面---加入private修饰:为了数据的安全性,它的访问---就要外部类的公共访问间接访问...

非static内部类不能有static修饰的变量或方法非static的内部类，在外部类加载的时候，并不会加载它，所以它里面不能有静态变量或者静态方法。1、static类型的属性和方法，在类加载的时候就会存在于内存中。2、要使用某个类的static属性或者方法，那么这个类必须要加载到jvm中。静态成员和静态方法是随着类的加载而存在的，也就是说内部类的静态属性是随着类的加载的，但是内部类的实例 是创建后才存在的，也就是说其静态属性优先存在于他的类实例的存在 这显然是矛盾的，所以要把内部类设为静态的 这样他们的生命周期就是相同了14

伪代码举例:人首先身体---身体内有心脏class Body{//内部类:心脏private  class Heart{  //加入private:保证数据的安全性//手术public void operator(){System.out.println("心脏搭桥手术....") ;}}//外部类提供一些公共访问public void method(){if("如果你是外科医生"){Heart heart = new Heart() ;heart.operator() ;}}}//外部类直接访问成员内部类的成员

3）如果当前成员内部类是静态的,  里面的方法无论是静态的还是非静态的,都只能访问外部类的静态成员,包括私有!如何直接访问静态成员内部类的成员呢?将静态的成员内部类看成是外部类的静态成员访问直接访问方式外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

class Outer3{//定义非静态的成员变量public int num = 50 ;private static int num2 = 20 ;//定义成员内部类:静态的           ---->静态的成员内部类可以看成是外部类的静态成员static class Inner3{//此时类都是静态public void show(){// System.out.println(num);System.out.println(num2);}public static void show2(){// System.out.println(num);System.out.println(num2);}}
}
//测试类
public class InnerClassDemo3 {public static void main(String[] args) {// 外部类名.内部类名 对象名  = 外部类对象.内部类对象;//Outer3.Inner3 oi = new Outer3().new Inner3() ;  适用不了了//   外部类名.内部类名 对象名 = new 外部类名.内部类名() ;Outer3.Inner3 oi = new Outer3.Inner3() ;oi.show();oi.show2() ; //静态---不推荐对象名访问System.out.println("------------------------------");//show2()的另一种方式Outer3.Inner3.show2(); //show2()静态方法}
}

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();}
}
```markdown面试题:局部内部类访问局部变量的时候,此时局部变量应该注意什么?(JDK7/JDK8),为什么要加入final关键字呢?```markdown如何此时Java环境是Jdk7,局部内部类访问局部变量时,此时该变量必须显示加入final修饰目前环境是JDK8环境,做了什么优化?通过反编译查看class Outer2$1Inner2{final int val$num;  num已经加入了final修饰final Outer2 this$0;public void show(){System.out.println(val$num);}Outer2$1Inner2(){this.this$0 = this$0;val$num = I.this;super();}}原因:局部变量的生命周期是随着方法调用而存在,随着方法调用结束而消失而当前外部类对象调用method 方法的时候,此时num进入栈内存,在局部位置创建了局部内部类对象而局部内部类对象调用它的成员方法访问该变量,方法method方法结束之后,内部类对象不会立即消失,它里面的成员方法在访问局部变量,局部变量必须变成常量,常驻内存,否则如果当前变量消失了,局部内部类的成员依然在访问就会出现冲突! 所以 jdk7 收到必须加入final修饰,jdk8通过jvm已经做了优化了,无需手动加入final修饰

4.匿名内部类

匿名内部类没有名字的内部类，一般在我们局部位置使用!
格式:匿名内部类它是内部类的一种简化格式new 类名(可以是抽象类,也可以具体类)或者是接口名(){重写功能} ;
匿名内部类的本质:继承了该类或者是实现了该接口的子类对象

//定义一个接口
interface Inter{void show() ; //public abstract修饰 (可以省略)void show2() ;
}
/*class InterImpl implements  Inter{@Overridepublic void show() {}@Overridepublic void show2() {}
}*/
//外部类
class Outer3{//定义一个成员方法public void method(){// class Inner3{} 有名字内部类//使用匿名内部类去写/*new 类名(可以是抽象类,也可以具体类)或者是接口名(){重写功能} ;*///情况1:接口中只有一个方法/*   new Inter(){ //接口名@Overridepublic void show() {System.out.println("show Inter...");}}.show() ;*///情况2:接口中有两个方法/*   new Inter(){@Overridepublic void show() {System.out.println("show Inter...");}@Overridepublic void show2() {System.out.println("show2 Inter...");}}.show() ;new Inter(){@Overridepublic void show() {System.out.println("show Inter...");}@Overridepublic void show2() {System.out.println("show2 Inter...");}}.show2() ;*///优化:给匿名内部类起一个名字Inter i = new Inter(){@Overridepublic void show() {System.out.println("show Inter...");}@Overridepublic 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();}
}

1）方法的形式参数是接口

方法的形式参数如果是一个接口,实际需要传递的接口子实现类对象方式1:将接口的子实现类定义出来方式2;使用接口的匿名内部类

//定义一个结婚的接口
interface Mary{void mary() ;
}//定义一个子类实现类
class You implements  Mary{@Overridepublic void mary() {System.out.println("要结婚了,很开心...");}
}//定义一个LoveDemo类
class LoveDemo{public void funciton(Mary mary){//形式参数是一个接口mary.mary();}
}//测试类
public class LoveTest {public static void main(String[] args) {//方式1:需要调用LoveDemo类中的function方法LoveDemo loveDemo  = new LoveDemo() ; //或者使用匿名对象//接口多态Mary mary = new You() ;loveDemo.funciton(mary);System.out.println("----------------------------------------");//方式2:接口的匿名内部类//创建LoveDemo类对象LoveDemo ld = new LoveDemo() ;ld.funciton(new Mary() {  //内部类@Overridepublic void mary() {System.out.println("要结婚了,很开心...");}});}
}

2）关于匿名内部类在开发中的使用

关于匿名内部类在开发中的使用:方法的形式参数如果是一个抽象类,那么实际参数可以需要接口的子类对象1)将子类定义出来 继承自抽象类2)直接使用抽象类的匿名内部类

//定义一个结婚的接口
interface Mary{void mary() ;
}//定义一个子类实现类
class You implements  Mary{@Overridepublic void mary() {System.out.println("要结婚了,很开心...");}
}//定义一个LoveDemo类
class LoveDemo{public void funciton(Mary mary){//形式参数是一个接口mary.mary();}
}//测试类
public class LoveTest {public static void main(String[] args) {//方式1:需要调用LoveDemo类中的function方法LoveDemo loveDemo  = new LoveDemo() ; //或者使用匿名对象//接口多态Mary mary = new You() ;loveDemo.funciton(mary);System.out.println("----------------------------------------");//方式2:接口的匿名内部类//创建LoveDemo类对象LoveDemo ld = new LoveDemo() ;ld.funciton(new Mary() {@Overridepublic void mary() {System.out.println("要结婚了,很开心...");}});}
}

//抽象类
abstract  class Person{public  abstract  void work() ;
}//定义一个子类继承自Person类
class Student extends  Person{@Overridepublic void work() {System.out.println("good good study ,day day up!!");}
}//PersonDemo类
class PersonDemo{public void method(Person p){//方法的形式参数是一个抽象类p.work();}
}//测试类
public class PersonTest {public static void main(String[] args) {//调用PersonDemo类中的method方法?//创建PersonDemo类对象 /或者匿名对象PersonDemo pd = new PersonDemo() ;//抽象类多态:创建子类对象Person p = new Student() ; //定义一个子类Studentpd.method(p) ;System.out.println("----------------------------------------");//使用匿名内部类去完成:/*** new 类名(抽象类)/接口名(){*     重写方法* } ;*///调用PersonDemo类中的method方法?PersonDemo pd2 = new PersonDemo() ;pd2.method(new Person(){ //实际参数也是传递抽象类的子类对象(抽象类的匿名内部类)@Overridepublic void work() {System.out.println("good good Study,day day Up!!");}});}
}

看程序,写结果
要求:需要在控制台分别打印30,20,10

/*考点:外部类直接访问非静态的成员内部类的格式外部类的成员变量的方法方式,(在成员内部类的成员方法中)成员变量,局部变量名称都一样(就近原则)外部类和内部类没有继承关系
*/class Outer{int num = 10 ;//成员内部类class Inner{int num = 20 ;public void show(){int num = 30;//补全代码System.out.println(num);System.out.println(this.num);//this限定 :this.变量名:当前类的成员变量// System.out.println(new Outer().num) ; //方式1:new Outer().numSystem.out.println(Outer.this.num) ; //方式2:外部类的this限定}}
}
public class OuterTest {public static void main(String[] args) {Outer.Inner oi = new Outer().new Inner() ;oi.show();}
}

笔试题

• 补全代码—>在控制台输出"HelloWorld"

/*给定一个接口*/interface Inter{void show()  ;}class Outer{//补全代码}class Test{public static void main(String[] args){Outer.method().show() ;}}

interface Inter{void show() ;
}
class Outer2{public static Inter method(){//返回结果?//返回值是一个接口类型,需要返回的是接口的子实现类对象//方式1:定义子实现类(不让我们创建子类)//方式2:可以使用接口匿名内部类(考点)return new Inter(){@Overridepublic void show() {System.out.println("HelloWorld...");}} ;}
}
public class Test {public static void main(String[] args) {/* Inter inter = Outer2.method(); //Inter inter = new 子实现类() ;匿名内部类的方式完成的inter.show() ;*/Outer2.method().show();/*** 类名.method()----->说明当前这个是一个静态方法* Outer2.method().show()---->前面部分Outer2.method()--->是由返回值类型的方法, 可以调用接口中的show方法* show方法是接口的方法,所以返回的接口类型*/}
}

3）方法的返回值是接口或抽象类型

​ 需要返回的当前接口的子实现类对象

接口

interface Love{void love() ;
}
class LoveDemo{public Love function(){//return ?//通过接口多态//Love love = new Student() ;//return love ;//匿名对象// return new Student() ;//使用接口的匿名内部类/*** new 类名/接口名(){**     重写方法* } ;*/return  new Love(){@Overridepublic void love() {System.out.println("爱Java,爱学习...");}} ;}
}//定义接口的子实现类
class Student implements  Love{@Overridepublic 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  =  new Student() ;love.love();System.out.println("------------------");//方式2:接口匿名内部类的方式LoveDemo ld2 = new LoveDemo() ;Love l = ld2.function();l.love();}
}

抽象类

abstract  class Person{public abstract  void work() ;
}
class PersonDemo{public Person method(){//return ?//抽象类多态// Person person = new Programmer() ;// return  person ;// return new Programmer() ;//直接抽象类的匿名内部类return new Person(){//相当于Person类的子类对象(匿名内部类的本质)@Overridepublic void work() {System.out.println("程序员日日夜夜敲代码");}} ;}
}
//定义一个子类
class Programmer extends  Person{@Overridepublic 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();}
}

16.常用类

java.lang.Object:是类结构层次的根类(超类--->父类),所有的类都默认继承自Object子类(派生类)使用JDK提供的API文档学习常用类中的常用功能API:Application Programming Interface:应用程序接口开发文档

1.getClass

Object功能类的getClass()方法public final Class<?> getClass():表示正在运行的类  (就是字节码文件对象)Class----->反射的时候去使用先去使用:Class类:功能:public String getName():获取当前类的全限定名称(包名.类名)Object类中的getClass()/finalize()/hashCode()以及以后常用类功能中如果native关键字:本地方法,非java语言底层实现另外一个功能public int hashCode():(了解)获取对象的一个哈希码值 (本质不是地址值,可以把它理解为地址值)----跟哈希表有关系(HashMap)一般情况:不同的对象获取的哈希码值是不同的 ,(但是中文字符,可能内容不一样,但是哈希码值不同!)底层是通过哈希表算出来的,目前先了解!

面试题:获取一个类的字节码文件对象有几种方式? 三种第一种:通过Object类的getClass()--->Class       :正在运行的java类: class  包名.类名第二种:任意Java类型的class属性----获取当前类的字节码文件对象Class第三种方式:Class里面forName("类的全限定名称(包名.类名)") ; (使用最多)

//public class Student extends Object { //后面extends Object:任何类都默认继承自Object
public class Student  {public static void get(){System.out.println("get student");}
}public class ObjectDemo {public static void main(String[] args) throws ClassNotFoundException {//创建一个学生类对象Student s  = new Student() ;Class c1 = s.getClass();System.out.println(c1);//class com.qf.generator_class_05.Student    class 包.类名Class c2 = s.getClass();System.out.println(c2);//class com.qf.generator_class_05.Student    class 包名.类名System.out.println(c1 == c2);//==在基本数据类型里面:比较的是数据值相同,在引用类型:比较的是两个对象的地址值是否相同//Student.class---->就加载一次System.out.println("---------------------------------");Student s2 = new Student() ;System.out.println(s == s2);//false :两个对象System.out.println("----------------------------------");//获取c1/c2 所代表的类 的全限定名称// Class ---->class com.qf.generator_class_05.StudentString name1 = c1.getName();String name2 = c2.getName();System.out.println(name1);System.out.println(name2);System.out.println("--------------------------------");//Class类中public static Class forName(String classname): 后期反射中使用Class c3 = Class.forName("com.qf.generator_class_05.Student");System.out.println(c1==c3);System.out.println(c2==c3);System.out.println("--------------------------------");Class c4 =  Student.class ; //任意Java类型的class属性----获取当前类的字节码文件对象ClassSystem.out.println(c4);System.out.println(c1==c4);System.out.println(c2==c4);System.out.println(c3==c4);System.out.println("---------------------------------------");//创建两个对象// public int hashCode()Student s3 = new Student() ;Student s4 = new Student() ;System.out.println(s3.hashCode());System.out.println(s4.hashCode());System.out.println("helloworld".hashCode());System.out.println("javaee".hashCode());System.out.println("helloWorld".hashCode());System.out.println("helloworld".hashCode());}
}

2.toString

Object的public String toString()返回对象的字符串表示形式。结果应该是一个简明扼要的表达，容易让人阅读。  建议所有子类覆盖此方法。描述一个对象:是由很多属性(成员变量组成),应该看到的具体的属性描述要么手动方式(不推荐)也可以直接快捷键----重写toString即可大部分的常用类或者后面的集合都会重写Object类的toString()

public class Student extends  Object {String name ;int age ;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}//手动重写Object的toString/* @Overridepublic String toString() {return "姓名是"+name+",年龄是"+age;}*///alt+ins--->toString()即可@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';//描述学生对象的成员信息表达式}
}public class ObjectDemo {public static void main(String[] args) {//通过有参构造方法创建一个学生对象Student s = new Student("高圆圆",42) ;//直接输出对象名称 --->会默认调用它的父类:Object的toString方法System.out.println(s);//com.qf.object_06.Student@1540e19dSystem.out.println("-----------------------------------");/*** Object类的toString方法的原码*  public String toString() {*         return getClass().getName() + "@" + Integer.toHexString(hashCode());*     }**     Integer类:int类型的包装类类型*          public static String toHexString(int i) :将整数转换成16进制数据--结果以String类型展示*//*System.out.println(s.getClass().getName()+"@"+Integer.toHexString(s.hashCode()));System.out.println(s.toString());*/System.out.println(s.toString());/*String str = new String("hello") ;System.out.println(str);*/}
}

3.equals

Object类的equals方法public boolean equals(Object obj)判断当前obj对象是否和当前对象想等

面试题:equals和==的区别?==:   连接的基本数据类型:比较的是数据值否相同==:   连接的是引用类型,比较的是地址值是否相同equals方法:如果使用Object默认的 : 底层用 == , 默认比较的还是两个对象的地址值是否相同Student s1  = new Student("文章",35) ;Student s2  = new Student("文章",35) ;s1和s2虽然地址值不同,他们的成员的内容相同,认为他是同一个人,但是如何让s1.equals(s2)为true:针对equals来说比较的是成员信息内容是否相同;重写Object的equals方法同时还需要重写hashCode内容相同,还需要比较哈希码值相同alt+ins--->hashcode+equals方法重写之后,就比较的是成员信息的内容是否相同!

public class Student {String name ;int age ;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}//重写Object类的toString@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}//重写了equals和code方法//首先比较:s1和s2它的哈希码值是否相同@Overridepublic int hashCode() {int result = name.hashCode();//name:String     "文章".hashCode() ; 837177result = 31 * result + age; //31 * 837177 + 35return result;  //得到一个结果}//比较完哈希码值之后,然后还要确定一下成员内容是否都一样(名字----"中文字符")//s1.equals(s2)@Overridepublic boolean equals(Object o) {   //Object o = new Student() ;  Student s2 = new Student() ;if (this == o) return true;     //if(this==o){//如果当前s1对象和s2对象地址值相同//return true ;// }if (o == null || getClass() != o.getClass()) return false;//如果s2对象为null或者是当前s1.getClass() 和s2.getClass()  字节码文件对象不相同,直接返回falseStudent student = (Student) o;  //向下转型: o--->Student studentif (age != student.age) return false;       //判断年龄是否相同(s1)  this.age !=student.age  (s2)return name.equals(student.name);       //姓名是一个:String//s1.name.equals(s2.name) ;//String类型 本身底层已经重写了Object类的equals方法,所以 直接比较的是字符串的内容是否相同}
}public class ObjectDemo {public static void main(String[] args) {//==int a = 10 ;int b = 15 ;System.out.println(a==b);//==链接的基本数据类型:比较的是数据值否相同System.out.println("--------------------------------------------");Student s1 = new Student("文章",35) ;System.out.println(s1);Student s2 = new Student("文章",35) ;System.out.println(s2);System.out.println(s1 == s2);System.out.println("--------------------------------------");//public boolean equals(Object obj)//Object obj = new Student() ;多态System.out.println(s1.equals(s2));//没有重写之前:执行的是Object类的equals()//重写之后,就比较的是对象的成员信息是否一致!System.out.println(s1.hashCode());System.out.println(s2.hashCode());System.out.println("文章".hashCode());/****Object类中的equals的源码*  public boolean equals(Object obj) {   //s1 ---this    obj---->s2*         return (this == obj);  return s1 == s2 ;   ==:引用类型:比较的是地址值是否相同*     }*/System.out.println("---------------------------------------------");//        String类型(大部分常用类都会重写equals)重写Object的equals方法,所以比较内容是否相同String str1 = "hello" ;String str2 = "hello" ;System.out.println(str1.equals(str2));String str3 = "world" ;String str4  = new String("world") ;System.out.println(str3.equals(str4));}
}

4.clone

克隆方法protected Object clone() throws CloneNotSupportedException:创建对象并返回该对象的副本这个方法会抛出一个异常,throws:表示的是可能出现异常,针对调用者必须进行处理要使用clone方法,当前某个对象所在的类必须实现"标记接口"Cloneable(没有字段(成员变量),也没有成员方法)实现这个接口,那么就可以使用Object的clone()方法

 /* 默认继承Object*  要进行克隆必须实现标记接口Cloneable*/
public class Student 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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class ObjectDemo {public static void main(String[] args) throws CloneNotSupportedException{//创建学生对象Student s1 = new Student("高圆圆",42) ;System.out.println(s1);System.out.println(s1.getName()+"---"+s1.getAge());System.out.println("-----------------------------------");//调用克隆方法clone()Object obj = s1.clone(); //已经克隆了(浅克隆:将s1地址值赋值给Objet)//向下转型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());}
}

5.Scanner

Scanner类:文本扫描器    java.util.Scaner ;1.构造方法:public Scanner(InputStream source) :创建一个文本扫描器形式参数是一个抽象类--->它通过System类里面的 public static final InputStream inSystem类中public final static InputStream in = null;本地方法(非Java语言实现)---> private static native void setIn0(InputStream in);底层方法一定会创建系统资源---->读取用户输入的 字符(整数,字符串...)
2.Scanner类提供判断功能:防止出现输入的类型和结果类型不匹配!public boolean hasNextXXX():判断下一个录入的是否为指定的XXX类型XXX nextXXX() 获取功能举例:public boolean hasNextInt()int nextInt()如果先录入int,在录入String---->nextLine()---- 录入的字符串数据被漏掉解决方案;1)直接使用next()---->String2)在使用nextLine()之前,在创建Scanner对象即可统一先用String----->全部接收     ----->后期可以通过Integer的特有功能将整数---->String前提条件:String---->数字字符串 "1","2","3"举例:本身:int录入5个学生的语文,数学,英语成绩,按照总分从高到底排序(可以TreeSet集合进行排序)语文成绩,数学成绩,英语成绩---->nextLine()---->String"98"  "78"     "60"String---    基本类型的包装类类型Integer--->int

public class ScannerDemo {public static void main(String[] args) {//创建键盘录入对象InputStream inputStream = System.in ;  //标准输入流  IO(Input 读 ,Output 写)  :Java高级特性:IOScanner sc = new Scanner(inputStream) ;// public Scanner(InputStream source) :创建一个文本扫描器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("您录入的数据和结果类型不匹配...");}//录入数据// int num = sc.nextInt();  //java.util.InputMismatchException// System.out.println("您要录入的数据是:"+num);}
}

6.String

1.java.lang.String:代表的字符串:字符串是一个常量,一旦被赋值了,其值(地址值)不能被更改推荐的使用方式:String  变量名 = "xxxx" ;//xxxx代表 的当前String的实例String类常用的功能:获取功能:int length():获取字符串长度2.面试题:在数组中有没有length方法,在String类中有没有length方法,在集合中有没有length方法数组中没有length方法,是length属性      int[] arr = new int[3] ;arr.length;String类中有length()集合中没有length(),----->size()获取元素数3.构造方法:1）public String():空参构造:空字符序列2）public String(byte[] bytes):将一个字节数组构造成一个字符串,使用平台默认的字符集(utf-8:一个中文对应三个字节) 解码编码和解码---保证字符集统一编码:将一个能看懂的字符串---->字节                "今天老地方见"  utf-8解码:将看不懂的字节---->字符串                    "今天老地方见" gbk3）public String(byte[] bytes,字符集):使用指定的字符集,将字节数组构造成一个字符串4）public String(byte[] bytes,int offset,int length):将指定的部分字节数组转换成字符串参数1:字节数组对象,参数2:指定的角标值  参数3:指定长度5）public String(char[] value):将字符数组构造成一字符串6）public String(char[] value,int offset,int count):将部分字符数组转换成字符串7）public String(String original):构造一个字符串,参数为字符串常量

public class StringDemo {public static void main(String[] args) {//测试String s = new String() ;System.out.println("s:"+s); //String类重写了Object的toString(),System.out.println(s.length());System.out.println("-------------------------------------------");byte[] bytes = {97,98,99,100,101} ;// public String(byte[] bytes)String s2 = new String(bytes) ;System.out.println(s2);System.out.println(s2.length());System.out.println("-------------------------------------------");//public String(byte[] bytes,int offset,int length):String s3 = new String(bytes,2,2) ;System.out.println(s3);System.out.println(s3.length());System.out.println("-------------------------------------------");//public String(char[] value)char[] chs = {'我','爱','高','圆','圆'} ;String s4 = new String(chs) ;System.out.println(s4);System.out.println(s4.length());System.out.println("-------------------------------------------");//  public String(char[] value,int offset,int count)String s5 = new String(chs,1,4) ;System.out.println(s5);System.out.println(s5.length());System.out.println("---------------------------------------------");// public String(String original)String s6 = new String("hello") ; //创建字符串对象,常量值:helloSystem.out.println(s6);String s7 = "hello" ; //推荐的方式System.out.println(s7);}
}

4.面试题:String s1 = "hello" ;String s2 = new String("hello") ;在内存中分别创建了几个对象?第一个创建了一个对象,直接在常量池创建,开辟常量池空间第二个:创建了两个对象,一个堆内存中开辟空间,一个指向常量池(不推荐)

public class StringDemo2 {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));  //只管内容相同}
}
/*** String类型重写了Object的equals方法* Object 的equals**  public boolean equals(Object obj) {*         return (this == obj);   //默认比较的地址值*     }*** class String{**  private final char value[];  属性 value 字符数组* public boolean equals(Object anObject) {  Object anObject = new String() ;*         if (this == anObject) {  //判断当前字符串对象和传递进来S2对比*             return true;         //判断地址值相同*         }*         if (anObject instanceof String) {    //判断传进来的s2是否为String类型的实例*             String anotherString = (String)anObject; // 向下转型  String类型*             int n = value.length;            //获取了字符数组长度   this.value.length---->  int n = 5*             if (n == anotherString.value.length) {  //  if(s1的长度 5 == s2.value.length   5)*                 char v1[] = value;                  //char v1[] = this.value;  将s1---->v1字符数组*                                                      char v1[] = {'h','e','l','l','o'}*                 char v2[] = anotherString.value;     //char v2[] =s2.value; 将s2----->v2字符数组*                                                      char v2[]  = {'h','e','l','l','o'}*                 int i = 0;               //统计变量*                 while (n-- != 0) {        // i=0*                     if (v1[i] != v2[i])      // v1[0] != v2[0]  ---->'h'     v1[1] != v2[1]*                         return false;*                     i++;                 /i=1*                 }*                 return true;         //true*             }*         }*         return false;*     }*   }*/

5.== 和equals==:连接引用类型比较的是地址值equals:默认比较地址值,但是String类重写equals方法,所以内容是否相同看程序,写结果直接赋值的形式字符串变量相加,常量池中先开空间,再拼接字符串常量相加,先相加,然后看结果是否在常量池中存在; 如果存在,直接返回当前地址值,如果不存在,在常量池开辟空间!

public class StringTest {public static void main(String[] args) {String s1  = "hello" ;String s2 =  "world" ;String s3 = "helloworld" ;System.out.println(s3 == (s1+s2)); //s1+s2:先开空间,在拼接  falseSystem.out.println(s3.equals(s1+s2)); //trueSystem.out.println("----------------------");System.out.println(s3 == "hello"+"world"); //先拼接,然后再常量池中找,存在,直接返回地址System.out.println(s3 .equals("hello"+"world"));}
}

6.String类的常用的转换功能

String类的常用的转换功能: (重点)1）byte[] getBytes()  :将字符串转换成字节数组 (编码)如果方法为空参,使用平台默认的编码集进行编码(utf-8:一个中文对应三个字节)2）byte[] getBytes(String charset):使用指定的字符集进行编码解码的过程:将看不懂的字节数----->String3）String(byte[] bytes):使用默认字符集进行解码4）String(byte[] bytes,指定字符集)编码和解码必须要保证字符集统一字符集:gbk :一个中文两个字节(中国中文编码表)gb2312:gbk升级版(含义有一个中文字符:中国的中文编码表)iso-8859-1:拉丁文码表utf-8:任何的浏览器--->都支持 utf-8格式 (后期统一个)unicode:国际编码表JS:日本国际 电脑系统 一个字符集5）Arrays静态功能:public static String toString(int/byte/float/double...[] a):将任意类型的数组---->String6）public char[] toCharArray():将字符串转换成字符数组7）public String toString():返回自己本身---"当前字符串的内容"8）public String toUpperCase():将字符串转换成大写9）public String toLowerCase():将字符串转换成小写

public class StringDemo {public static void main(String[] args) throws UnsupportedEncodingException {//定义一个字符串String str = "中国" ;byte[] bytes = str.getBytes();//默认utf-8//byte[] bytes = str.getBytes("gbk");//指定字符集//public static String toString(byte[] a)System.out.println(Arrays.toString(bytes));//[-28, -72, -83, -27, -101, -67]//[-42, -48, -71, -6]System.out.println("------------------------------");//解码//String strResult = new String(bytes,"gbk") ;//gbk:一个中文对应两个字节 //使用平台默认解码集进行解码:   utf-8String strResult = new String(bytes) ;// //使用平台默认解码集进行解码:   utf-8System.out.println(strResult);System.out.println("--------------------------------------");//定义一个字符串String s2 = "helloworldJavaEE" ;// public char[] toCharArray()char[] chs = s2.toCharArray();//遍历字符数组for(int x = 0 ; x < chs.length;  x ++){System.out.println(chs[x]);}System.out.println("-----------------------");System.out.println(s2.toString());System.out.println("-----------------------");//转换大小写System.out.println(s2.toUpperCase());System.out.println(s2.toLowerCase());}
}

7.String类型的判断功能

public boolean equals(Object anObject):比较两个字符的内容是否相同 (区分大小写)
public boolean equalsIgnoreCase(String anotherString):比较两个字符串是否相同(不区分大小写)
public boolean startsWith(String prefix):判断字符串是否以指定的内容开头
public boolean endsWith(String suffix):判断字符串是否以指定的内容结尾
boolean isEmpty()  判断字符串是否为空 :若为空,则返回true;否则返回falseString s = "" ;// 空字符串 ,存在String对象 ""String s = null ; 空值 (空对象) null:引用类型的默认值

public class StringDemo2 {public static void main(String[] args) {String s1 = "helloJavaEE" ;String s2 = "hellojavaee" ;//  public boolean equals(Object anObject):比较两个字符的内容是否相同 (区分大小写)System.out.println("equals:"+s1.equals(s2));//   public boolean equalsIgnoreCase(String anotherString)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());}
}

8.String类的获取功能

String类的获取功能:(重点)1）int length():获取字符串长度2）public char charAt(int index);获取指定索引处的字符3）public String concat(String str):将指定的字符串和当前字符串进行拼接,获取一个新的字符串4）public int indexOf(int ch):返回指定字符第一次出现的索引值5）public int lastIndexOf(int ch):返回值指定字符最后一次出现的索引值6）public String[] split(String regex):拆分功能:通过指定的格式将字符串---拆分字符串数组7）public String substring(int beginIndex) :从指定位置开始默认截取到末尾角标从0开始8）public String substring(int beginIndex,int endIndex)从指定位置开始,截取到位置结束(包前不包右)只能取到endIndex-1处9）public static String valueOf(boolean/int/long/float/double/char...Object b)万能方法,将任意类型转换String类型

public class StringDemo {public static void main(String[] args) {String str = "helloworldJavaEE" ;// public char charAt(int index);获取指定索引处的字符System.out.println("charAt():"+str.charAt(4));System.out.println("---------------------------------");//public String concat(String str):将指定的字符串和当前字符串进行拼接,获取一个新的字符串//字符串最传统的拼接:直接  定义一个String s = "" ;  s+任何数据="xxx" ;//提供了一个功能System.out.println("concat:"+str.concat("R").concat("Go"));System.out.println("-----------------------------------");//   public int indexOf(int ch):返回指定字符第一次出现的索引值// public int lastIndexOf(int ch):返回值指定字符最后一次出现的索引值System.out.println("indexOf():"+str.indexOf("o"));System.out.println("lastIndexOf():"+str.lastIndexOf("o"));System.out.println("-----------------------------------");//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");}System.out.println();System.out.println("-----------------------------------");/***  public String substring(int beginIndex) :从指定位置开始默认截取到末尾*                                    角标从0开始*  public String substring(int beginIndex,int endIndex)*/// String str = "helloworldJavaEE" ;System.out.println("subString():"+str.substring(5));System.out.println("subString():"+str.substring(5,9));//worlSystem.out.println("-----------------------------------");//public static String valueOf(基本类型以及Object)System.out.println("valueOf:"+String.valueOf(100)); //100--->"100"}
}

9.字符串其他功能

     1）public String replace(char target,char replacement):替换功能将指定的内容使用target字符进行替换2）public String replaceAll(String regex, String replacement) :将指定的和参数1正则表达式匹配的字符串 使用replacement进行替换参数1:[0-9]   --->如果字符是数字字符参数2: "*"替换掉3）public String trim():去除字符串两端的空格重点4）public int compareTo(String anotherString):按照字典顺序比较,返回值是int

public class StringDemo2 {public static void main(String[] args) {String s = "helloworld" ;System.out.println("replace():"+s.replace('l','k'));System.out.println("-------------------------------------");//public String trim():去除字符串两端的空格///*** 网页中;填写日期的时候* 应用场景:*              在IO流中:可能数据传输过程中: "      hello     " ,可以通过trim去除空格  (数据网络中传输,获取字符串数据之后,先去除空格,然后再操作!)*            String 文本  "2021-7-27"------>日期对象  Date*                  解析过程: 如果日期文本中有空格字符串---->解析就会发生异常,去除两端空格*/String s2 = "hello";System.out.println("s2:"+s2+"----");String s3 = "      hello  " ;System.out.println("s3:"+s3);System.out.println("s3:"+s3.trim()+"----");System.out.println("------------------------------------");//        public int compareTo(String anotherString):按照字典顺序比较,返回值是intString str1 = "abc" ;//字典顺序:就是我们26个字母,a,b,c,d,e,f,g,hString str2 = "hello" ;System.out.println(str1.compareTo(str2));String str3 = "hel" ;System.out.println(str2.compareTo(str3));}
}

/*面试题
String s1 = "hello" ;           "abc"
String s2 = "hel" ;             "hello"s1.compareTo(s2) ;使用s1调用compareTo(s2):按照字典顺序比较:结果是多少？是怎么运行的?*/class String{private final char value[];//value属性//按照字典顺序比较public int compareTo(String anotherString) {  //s2int len1 = value.length;            //计算第一个字符数组的长度  s1.value.length = 5     3int len2 = anotherString.value.length;//s2.value.length---->3                           5int lim = Math.min(len1, len2); //Math.min(5,3) ---->lim = 3                            3char v1[] = value;          //char v1[] = s1.value= {'h','e','l','l','o'}       {'a','b','c'}char v2[] = anotherString.value;//char v2[] = s2.value = {'h','e','l'}          {'h','e','l','l','o'}int k = 0;          //统计变量k = 0while (k < lim) {           0 < 3   1< 3        2< 3  3< 3 (不成立)char c1 = v1[k];            //char c1 = v1[0]  ='h'   //char c1 = v1[1] = 'e'   // char c1  = v1[2] = 'l'               char c1 = v1[0] ='a'char c2 = v2[k];            //cahr c2 = v2[0] = 'h'  //char c2 = v2[1] = 'e'   // char c2 = v2[2] = 'l'                 char c2 = v2[1] ='h'if (c1 != c2) {return c1 - c2;  //c1- c2  =  'a' - 'h' = 97 - 104 = -7}k++;                //k=1      2        3}return len1 - len2;     //len1 - len2 = 5 -3 = 2}
}

7.StringBuffer

StringBuffer:字符串缓冲区 ---->类似于String,但是不一样 (可变的字符序列)线程安全------>线程----(多线程中说)线程依赖于进程存在!进程,能够被系统资源调用的独立单位一个进程可以有多个线程,每一个线程----->"执行单元"(任务)线程安全---->同步的----->执行效率低举例:银行类的网站/医疗网站ATM机取钱---->插卡--->输入密码---->查询余额---->取钱StringBuilder:和StringBuffer具有相互兼容的API,它是线程不安全的类---->不同步----->执行效率高举例:论坛网站博客...单线程程序中:jvm在进行编译的时候  使用StringBuilder去替换StringBuffer

1.StringBuffer的构造方法

      public StringBuffer() :空参构造,创建一个空字符序列的字符串缓冲去  (推荐)public StringBuffer(int capacity):构造一个字符串缓冲区对象,指定容量大小public StringBuffer(String str):指定字符序列,长度加上初始容量16(总容量)

2.获取功能

      public int length():获取字符数(长度)public int capacity():获取字符串缓冲区容量

public class StringBufferDemo {public static void main(String[] args) {StringBuffer sb = new StringBuffer() ;System.out.println("sb:"+sb); //空字符序列;重写Object的toString()System.out.println(sb.length());System.out.println(sb.capacity());System.out.println("------------------------------");StringBuffer sb2 = new StringBuffer(20) ;/***  内部实现---->调用父类的构造函数: 相当于内部创建了一个字符数组对象*    AbstractStringBuilder(int capacity) {*         value = new char[capacity];*     }*/System.out.println("sb2:"+sb2);System.out.println(sb2.length());System.out.println(sb2.capacity());System.out.println("------------------------------");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 sb4 = "world" ;// String str = "world" ;//  StringBuffer sb4 = str ;//String---->StringBuffer  :有的时候使用的String类型的功能,但是结果需要一个StringBuffer类型//StringBuffer--->String :可能使用过程中用的StringBuffer的功能,最终需要String类型}
}

3.添加功能

StringBuffer  append(任何类型) :将内容追加到字符串缓冲区中 (在字符串缓冲区的最后一个字符序列的末尾追加)返回值是字符串缓冲区本身...
public StringBuffer insert(int offset,String str):插入:在指定位置处插入指定的内容

public class StringBufferDemo {public static void main(String[] args) {//创建一个字符串缓冲区对象StringBuffer sb = new StringBuffer() ;System.out.println("sb:"+sb);//StringBuffer  append(任何类型)sb.append("hello").append("world").append(100).append('a').append(12.34).append(new Object()) ;System.out.println("sb:"+sb);System.out.println("----------------------------------");//public StringBuffer insert(int offset,String str)sb.insert(5,"高圆圆") ;System.out.println("sb:"+sb);}
}

4.删除功能

StringBuffer的删除功能public StringBuffer deleteCharAt(int index):删除指定索引处的缓冲区的字符序列,返回字符串缓冲区本身public StringBuffer delete(int start,int end):删除从指定位置到指定位置结束的字符序列(包含end-1处的字符),返回字符串缓冲区本身[start,end-1]

public class StringBufferDemo2 {public static void main(String[] args) {//创建一个StringBuffer对象 (默认初始容量16)StringBuffer buffer = new StringBuffer() ;buffer.append("hello").append("world").append("Javaee") ;System.out.println(buffer);System.out.println("---------------------------");//public StringBuffer deleteCharAt(int index)//删除e这个字符// System.out.println("deletCharAt():"+buffer.deleteCharAt(1));//删除第一个l字符// System.out.println("deletCharAt():"+buffer.deleteCharAt(1));//public StringBuffer delete(int start,int end)://删除world这个子字符串System.out.println("delete():"+buffer.delete(5,10));//5-9}
}

5.类型的相互转换(重点)

类型的相互转换(重点)开发中:本身A类型,由于需要使用B类型的功能,所以 A类型---->B类型A类型,需要使用B类型的功能,A--->B类型,使用完功能之后,又可能结果又需要A类型,B类型---->A类型String---->StringBufferStringBuffer---->String

public class StringBufferDemo3 {public static void main(String[] args) {//String---->StringBufferString s = "hello" ;//错误的写法// StringBuffer sb = s ;//两个类型不一致//方式1:StringBuffer有参构造方法StringBuffer sb = new StringBuffer(s) ;System.out.println(sb);System.out.println("---------------------------");//方式2:StringBuffer的无参构造方法 结合append(String str)StringBuffer sb2 = new StringBuffer() ;sb2.append(s) ;//追加功能System.out.println(sb2);System.out.println("-------------------------------------------");//StringBuffer---->String//创建字符串缓冲区对象StringBuffer buffer = new StringBuffer("helloJavaee") ;//方式1:String类型的构造方法//public String(StringBuffer buffer)String  str = new String(buffer) ;System.out.println(str);System.out.println("-------------------------------------------");//方式2:StringBuffer的public String toString()方法String str2 = buffer.toString();System.out.println(str2);}
}

6.反转功能

StringBuffer的特有功能
public StringBuffer reverse(),反转之后,返回的是字符串缓冲区本身

//   键盘录入一个字符串,将字符串进行反转--->使用功能改进public class StringBufferDemo4 {public static void main(String[] args) {Scanner sc = new Scanner(System.in) ;//提示并录入System.out.println("请您输入一个字符串:");String line = sc.nextLine() ;//需要用StringBuffer的特有功能 reverse//line---->StringBuffer类型StringBuffer sb = new StringBuffer(line) ;String result = sb.reverse().toString();System.out.println(result);System.out.println("-----------------------------");//调用功能String result2 = reverse(line);System.out.println(result2);}
}

7.截取替换功能

StringBuffer的截取功能public String substring(int start):从指定位置开始,默认截取到末尾,返回值是新的字符串public String substring(int start,int end):从指定位置开始到指定end-1结束进行截取,返回的新的字符串
StringBuffer的替换功能public StringBuffer replace(int start,     int end,       String str)      起始索引     结束索引(end-1)      替换的内容

public class StringBufferDemo5 {public static void main(String[] args) {StringBuffer sb = new StringBuffer() ;sb.append("hello").append("world").append("javaee").append("anroid") ;System.out.println("sb:"+sb);// System.out.println(sb.substring(5));//subString(xx)---->截取的新的字符串//System.out.println("sb:"+sb);// System.out.println(sb.substring(5,10));//end-1位置System.out.println("------------------------------------");//public StringBuffer replace(int start,       起始索引//                          int end,         结束索引(end-1)//                              String str)      替换的内容System.out.println(sb.replace(5,10,"高圆圆"));}
}

8.面试题

面试题1:StringBuffer和数组的区别?数组:只能存储同一种数据类型容器数组可以存储基本类型,也可以存储引用类型数组的最大特点:长度固定StringBuffer:支持可变的字符序列里面存储可以存储任意类型的元素append(int/char/double/float/Obejct/String)isnert(int offert,int/char/double/float/Obejct/String)一般情况:开发中 将StringBuffer----->String面试题2:StringBuffer,StringBuilder和String的区别?String:字符串是一个常量,一旦被赋值,其值不能更改/作为形式参数属于特殊的引用类型,形式参数的改变不会实际参数StringBuffer:可变的字符序列,线程安全的类----同步的----->执行效率低(线程角度)StringBuilder:可变的字符序列.和StringBuffer具有相互兼容的api,单线程程序中(只考虑执行效率,不考虑安全问题),会使用StringBuilder替代StringBuffer作为方法的形式参数,形参的改变会直接实际参数

8.Integer

Integer:int类型的包装类类型(引用类型),包含了int类型的原始数据值为什么将Integer基本类型四类八种都会 对应的各自的引用类型int----->String需要基本类型和String类型之间转换:需要中间桥梁(基本类型对应的包装类类型)整数类型                    引用类型(默认值都是null)byte                        Byteshort                       Shortint                         Integerlong                        Long浮点类型float                       Floatdouble                      Double字符类型char                         Character布尔类型boolean                      Boolean

1.进制转换与极值

需求:进制的转换----就可以使用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的最小值

public class IntegerDemo {public static void main(String[] args) {System.out.println(Integer.toBinaryString(100));System.out.println(Integer.toOctalString(100));System.out.println(Integer.toHexString(100));System.out.println("----------------------");System.out.println(Integer.MIN_VALUE);//-2的31次方System.out.println(Integer.MAX_VALUE);//2的31次方-1}
}

2.Integer的构造方法

 Integer(int value):可以将int类型保证为Integer类型Integer(String s) throws NumberForamtException:  抛出一个数字格式化异常注意事项:当前字符串如果不是能够解析的整数的,就会出现数字格式化异常,s必须为 数字字符串

public class IntegerDemo2 {public static void main(String[] args) {//创建Integer类对象int i = 100 ;Integer integer = new Integer(i) ;System.out.println(integer);System.out.println("---------------------");//创建一个字符串// String s = "hello" ;String s  = "50" ;Integer integer2 = new Integer(s) ;System.out.println(integer2);}
}

3.自动拆装箱

JDK5以后新特性:自动拆装箱,可变参数,静态导入,增强for循环,<泛型>,枚举类自动拆装箱:基本类型---> 对应的包装类类型   (装箱)int---->Integer对应的包装类型---->基本类型    (拆箱)

public class IntegerDemo3 {public static void main(String[] args) {//创建Integer类对象int i = 100 ;Integer ii = new Integer(i) ;ii += 200 ;System.out.println("ii:"+ii);/***通过反编译工具查看int i = 100;Integer ii = new Integer(i);  //创建Integer类对象ii = Integer.valueOf(ii.intValue() + 200);      ii = Integer.valueIf(先拆箱--Integer--->int + 200)//将300赋值Integer变量ii,底层使用valueOf(int)--->int---->Integer 装箱System.out.println((new StringBuilder()).append("ii:").append(ii).toString());//以字符串形式输出出来*/}
}

4.int<—>String

将int---->StringInteger作为桥梁String---->int

public class IntegerDemo4 {public static void main(String[] args) {//int---->Stringint i = 50 ;//String result = "" ;//result = result + i ;//拼接符号//System.out.println(result);//"50"//使用功能//方式1: Integer类的静态功能//public static String toString(int i)String str = Integer.toString(i);System.out.println(str);System.out.println("------------------------");//方式2:int---->Integer---->public String toString()Integer ii = new Integer(i) ;String str2 = ii.toString(); //底层使用的方法public static String toString(int i)System.out.println(str2);System.out.println("----------------------------------");//String--->int(使用居多)//开发中:浏览器(客户端)---->传递给后端的数据(String类型)//方式1:public static int parseInt(String s)throws NumberFormatException:数字字符串 (使用最多)//通用方法:String--->long       Long.parseLong(String s)---->long// String ----double          Double  public static double parseDouble(String s)String s = "100" ;int result = Integer.parseInt(s);System.out.println(result);System.out.println("------------------------------------------");//String ---->Integer---->int//Integer的构造方法 Integer(String s)//Integer 的成员方法:int intValue()--->intInteger integer = new Integer(s) ;int result2 = integer.intValue();System.out.println(result2);}
}

5.看程序,写结果

public class IntegerTest {public static void main(String[] args) {Integer i1 = new Integer(127) ;Integer i2 = new Integer(127) ;System.out.println(i1==i2);//falseSystem.out.println(i1.equals(i2));//trueSystem.out.println("----------------------------");Integer i3 = 127 ;//valueOf(127)  127  (-128~127)    //直接从内部缓存区中取出数据并么有重新创建对象Integer i4 = new Integer(127) ;System.out.println(i3== i4);//falseSystem.out.println(i3.equals(i4));//trueSystem.out.println("-----------------------------");Integer i5 = 128 ;  //128已经超出了范围 :new Integer(128)Integer i6 = new Integer(128) ;System.out.println(i5==i6); //falseSystem.out.println(i5.equals(i6)); //trueSystem.out.println("-------------------------------");Integer i7 = 127 ;Integer i8 = 127 ;System.out.println(i7==i8); //true  IntegerCache:缓存区取出数据System.out.println(i7.equals(i8)); //trueSystem.out.println("-------------------------------");Integer i9 = 128 ;//  缓存区中范围:-128~127           return new Integer(128)Integer i10 = 128 ;System.out.println(i9==i10);//falseSystem.out.println(i9.equals(i10));//true/* Integer i = 127 ;System.out.println(i);*//*** 翻译工具查看:执行底层的valuOf()* Integer i = Integer.valueOf(127);*      System.out.println(i);*/}
}

//   Integer i = 127 ;class Integer{public static Integer valueOf(int i) { //127是否在 -128到127之间 :内部缓存区中存储的常量值if (i >= IntegerCache.low && i <= IntegerCache.high){return IntegerCache.cache[i + (-IntegerCache.low)];- -128 =  127+128}else{return new Integer(i);//创建一个新Integer对象}}//静态的成员内部类:内部缓存区private static class  IntegerCache {static final int low = -128;static final int high;static final Integer cache[];Integer 数组int h = 127 ;/..high = h;}}

9.Charcater

Charcater :char类型的包装类类型
构造方法public Character(char value)
主要了一些功能1）public static boolean isUpperCase(char ch):判断当前字符是否大写字母字符2）public static boolean isLowerCAse(char ch):是否为小写字母字符3）public static boolean isDigit(char ch):是否为数字字符//String转换的功能很类似4）public static char toLowerCase(char ch):将字符转换成小写5）public static char toUpperCase(char ch):将字符转换成大写

public class CharacterDemo {public static void main(String[] args) {//创建字符类对象Character character = new Character('a') ;
//        Character character = new Character((char)(97)) ;System.out.println(character);System.out.println("---------------------------------");System.out.println("isUpperCase():"+Character.isUpperCase('A'));System.out.println("isUpperCase():"+Character.isUpperCase('a'));System.out.println("isUpperCase():"+Character.isUpperCase('0'));System.out.println("---------------------------------");System.out.println("isLowerCase():"+Character.isLowerCase('A'));System.out.println("isLowerCase():"+Character.isLowerCase('a'));System.out.println("isLowerCase():"+Character.isLowerCase('0'));System.out.println("---------------------------------");System.out.println("isDigit():"+Character.isDigit('A'));System.out.println("isDigit():"+Character.isDigit('a'));System.out.println("isDigit():"+Character.isDigit('0'));// char ch = 'a' ;// System.out.println(Character.toUpperCase(ch));}
}

10.Calendar

日历类:java.util.Calendar
Calendar:提供一些诸如 获取年,月,月中的日期 等等字段值抽象类,不能实例化如果一个类没有抽象方法,这个类可不可以定义为抽象类? 可以,为了不能实例化,通过子类间接实例化
不能实例化:静态功能,返回值是它自己本身public static Calendar getInstance()
成员方法:public final void set(int year,int month,int date) : 设置当前日历的年月日public int get(int field):根据给定日历字段----获取日历字段的值(系统的日历)public abstract void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量参数1:日历字段参数2:偏移量

public class CalendarDemo {public static void main(String[] args) {//创建日历类对象//获取系统的年月日//public static Calendar getInstance()Calendar calendar = Calendar.getInstance();//System.out.println(calendar);//获取年//public static final int YEARint year = calendar.get(Calendar.YEAR) ;//获取月://public static final int MONTH:0-11之间int month = calendar.get(Calendar.MONTH) ;//获取月中的日期//public static final int DATE//public static final int DAY OF MONTH : 每个月的第一天1int date = calendar.get(Calendar.DATE) ;System.out.println("当前日历为:"+year+"年"+(month+1)+"月"+date+"日");System.out.println("------------------------------------------------");//获取3年前的今天//给year设置偏移量// public abstract void add(int field,int amount)calendar.add(Calendar.YEAR,-3);//获取year = calendar.get(Calendar.YEAR) ;System.out.println("当前日历为:"+year+"年"+(month+1)+"月"+date+"日");}
}

11.Date

java.util.Date:表示特定瞬间,精确到毫秒!它还允许格式化和解析日期字符串
构造方法:public Date():当前系统时间格式public Date(long date):参数为 时间毫秒值---->Date对象  (1970年1月1日...)

public class DateDemo {public static void main(String[] args) {//创建日期类对象Date date  = new Date() ;System.out.println(date);//Wed Jul 28 17:32:06 CST 2021 日期对象System.out.println("------------------------");long time = 60*60 ;Date date2 = new Date(time) ;System.out.println(date2);}
}

2.格式化

java.util.Date-----String  格式化过程DateForamt:抽象类----提供具体的日期/格式化的子类:SimpleDateFormatformat(Date对象)--->StringSimpleDateFormat:构造函数public SimpleDateFormat():使用默认模式public SimpleDateFormat(String pattern):使用指定的模式进行解析或者格式 (推荐)参数:一种模式表示年              "yyyy"表示月               "MM"表示月中的日期        "dd"一天中小时数          "HH"分钟数               "mm"秒数                 "ss"String:日期文本----->Date解析过程public Date parse(String source)throws ParseException如果解析的字符串的格式和 public SimpleDateFormat(String pattern)的参数模式不匹配的话,就会出现解析异常!封装成功工具类DateUtils: 构造方法私有,功能都是静态第一个将String---Date将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 class DateDemo2 {public static void main(String[] args) throws ParseException {//Date----->String:格式化//1)创建Date对象:表示当前系统时间对象Date date = new Date() ;System.out.println(date);//2)创建SimpleDateForamt对象:(中间桥梁)SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;//3)调用format:格式化String strDate = sdf.format(date);System.out.println(strDate);System.out.println("--------------------------------");//String---->Date(重点)//1)有一个日期文本格式//2)创建SimpleDateFormat对象指定一个模式//3)调用解析parse方法//注意:SimpleDateFormat解析模式必须和String日期文本格式匹配一致String source = "2008-5-12" ; //日期文本//SimpleDateFormat sdf2  = new SimpleDateFormat("yyyy年MM月dd日") ;SimpleDateFormat sdf2  = new SimpleDateFormat("yyyy-MM-dd") ;//public Date parse(String source)throws ParseExceptionDate dateResult = sdf2.parse(source);System.out.println(dateResult);}
}

这是针对java.util.Date日期对象和String:日期文本字符串进行相互转换的工具类

/*** @Author Kuke* @Date 2021/7/29** 这是针对java.util.Date日期对象和String:日期文本字符串进行相互转换的工具类*/
public class DateUtils {//构造方法私有化private DateUtils(){}//提供两个静态功能//Date---->String/*** 这个方法是针对将日期对象转换成日期文本字符串* @param date     需要被格式化的日期对象* @param pattern   需要指定的模式* @return  返回的日期文本字符串  结果 yyyy-MM-dd*/public static String date2String(Date date,String pattern){//分步走//创建SimpleDateFormat对象/* SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;String result = sdf.format(date);return  result ;*///一步走return new SimpleDateFormat(pattern).format(date) ;}//String--->Date: 解析过程: parse(String source) throws ParseException/*** 这个方法针对String日期文本字符串转换成日期对象* @param source   需要被解析的日期文本字符串* @param pattern   需要解析中使用的一种模式* @return  返回的就是日期对象Date*/public static Date string2Date(String source,String pattern) throws ParseException {return new SimpleDateFormat(pattern).parse(source) ;}
}

12.Random

java.util.Random类:伪随机数生成器
1.构造方法public Random(): 产生一个随机生成器对象,通过成员方法随机数每次没不一样的(推荐)public Random(long seed) :参数为long类型的值(随机数流:种子),每次通过成员方法获取随机数产生的随机数相同的
2.获取随机数的成员方法public int nextInt():获取的值的范围是int类型的取值范围(-2的31次方到2的31次方-1)public int nextInt(int n):获取的0-n之间的数据 (不包含n)
3.产生随机数:Math类的random方法public static double random();andom类:也能够去使用无参构造方法  + 成员方法public Random():+ public int nextInt(int n)

public class RandomDemo {public static void main(String[] args) {//创建一个随机数生成器
//        public Random(long seed)
//        Random random = new Random(1111) ;//每次通过随机数生成器产生的随机不同Random random =  new Random() ;//产生10个数for(int x = 0 ; x < 10 ; x ++){// public int nextInt():
//            int num = random.nextInt();//public int nextInt(int n)int num = (random.nextInt(30)+1);System.out.println(num);}}
}

13.Math

1.Math

java.lang.Math :针对数学运算的工具类,提供了很多方法1） public static int abs(int  a):                 绝对值方法2） public static double ceil(double a):         向上取整3） public static double floor(double a):        向下取整4） public static int max(int a,int b):          获取最大值5） public static int min(int a,int b):          获取最小值6） public static double pow(double a,double b): a的b次幂7） public static double random():[0.0,1.0):     随机数8） public static long round(double a):          四舍五入9） public static double sqrt(double a):         开平方根
Math类中的功能都是静态的,里面构造方法私有了!一般情况:工具类中构造方法都是会私有化(自定义的工具类),提供对外静态的公共访问方法(Java设计模式:单例模式)

public class MathDemo {public static void main(String[] args) {//abs()System.out.println(Math.abs(-100));    //100// public static double ceil(double a):向上取整System.out.println(Math.ceil(13.56));   //14.0// public static double floor(double a):向下取整System.out.println(Math.floor(12.45));        //12.0// public static int max(int a,int b):获取最大值System.out.println(Math.max(Math.max(10,30),50));//方法嵌套        50//public static double pow(double a,double b):a的b次幂System.out.println(Math.pow(2,3));     //8.0//ublic static long round(double a):四舍五入System.out.println(Math.round(13.78));     //14//  public static double sqrt(double a):开平方根System.out.println(Math.sqrt(4));       //2.0}
}

2.静态导入特性

JDK5的静态导入特性,必须方法静态的(导入到方法的级别)Math类的功能都是静态的,就可以使用静态导入import static 包名.类名.方法名;前提不能和其他方法名重名;

import static java.lang.Math.abs ;
import static java.lang.Math.random;public class MathTest {public static void main(String[] args) {System.out.println(Math.abs(-100));// System.out.println(java.lang.Math.abs(-100)); //默认就是使用当前abs方法,并不是Math提供的System.out.println(abs(-100));  //静态导入方法直接调用System.out.println(random()*100+1);}//自定义了方法名abspublic static int abs(int a){// System.out.println(a);return a ;}
}

14.BigDecimal

小数要进行精确计算-还可以计算的同时保留小数点后的有效位数Java提供的类: 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.37System.out.println(bg1.subtract(bg2));        //0.65System.out.println(bg1.multiply(bg2));        //0.3636// System.out.println(bg3.divide(bg4));  //不保留(整除)System.out.println(bg3.divide(bg4,3,BigDecimal.ROUND_HALF_UP));//四舍五入 1.980}
}

面试题:集合和数组有什么区别?1)长度区别数组:长度固定集合:长度可变
2)存储数据类型的区别数组:可以存储基本数据类型,也可以存储引用数据类型int[] arr = {100,200,50,"hello"} ;不行的集合:前提条件:集合中加入泛型<>          也是在模拟数组的特点:只能存储引用类型  Collection<E> :泛型<引用类型>
3)存储元素的区别:数组:存储的元素必须为同一种数据类型集合:如果没有加入泛型，就出任意类型的元素(必须引用类型)

17.集合

Collection:集合层次的根接口,一些集合允许元素重复(List),一些集合不允许元素重复(Set)一些集合有序(存储和取出一致)(List),一些集合无序(存储和取出不一致)(Set),JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和ListCollectionList最具体的子实现类ArrayList,LinkedList,Vector

1.功能

基本功能

     1）添加boolean add(Object e):添加元素  E(Element)2）删除:void clear() 暴力删除(将集合的素有元素全部干掉)boolean remove(Object o):从集合中删除指定的元素3）获取集合的元素数 :int size()4）判断功能:boolean isEmpty():判断集合是否为空,为空元素,则返回trueboolean contains(Object o):判断集合中是否包含指定元素,包含则返回true

//@SuppressWarnings("all") //jdk提供的内置注解:压制警告
public class CollectionDemo {public static void main(String[] args) {//创建Collection集合对象//接口多态Collection c = new ArrayList() ;System.out.println(c);//ArrayList重写了Object的toString()方法System.out.println("-----------------------------------------");// boolean add(Object e):添加元素  E(Element)//   boolean flag = c.add("hello");/*** 添加的原码* public boolean add(E e) {*         ensureCapacityInternal(size + 1);  // Increments modCount!!*         elementData[size++] = e;*         return true;  //永远返回true*     }*///System.out.println(flag);c.add("hello") ;c.add(100) ;c.add("javaee") ;System.out.println(c);//   void clear()
//        c.clear();// boolean remove(Object o):从集合中删除指定的元素//  System.out.println(c.remove(100));//int size()System.out.println(c.size());System.out.println("--------------------------");System.out.println(c.contains("world"));System.out.println(c.contains("javaee"));System.out.println(c.isEmpty());System.out.println(c);}
}

高级功能

Collection的高级功能1）boolean addAll(Collection c):添加一个集合中的所有元素2）oolean containsAll(Collection c):包含一个集合中的所有元素3）boolean removeAll(Collection c):删除集合中的所有元素, (删除一个算删除,还是删除所有)4）boolean retainAll(Collection c):A集合对B集合求交集, boolean的返回值是什么意思,交集的元素是保存在A中还是B中5）Collection最基本的遍历功能,不属于集合的专有遍历Object[] toArray():将集合转换成了对象数组

public class CollectionDemo2 {public static void main(String[] args) {//创建两个Collection集合对象Collection c1 = new ArrayList() ;c1.add("abc1") ;c1.add("abc2") ;c1.add("abc3") ;c1.add("abc4") ;Collection c2 = new ArrayList() ;c2.add("abc1") ;c2.add("abc2") ;c2.add("abc3") ;c2.add("abc4") ;c2.add("abc5") ;c2.add("abc6") ;c2.add("abc7") ;System.out.println(c1);System.out.println(c2);System.out.println("---------------------------------");//boolean addAll(Collection c):添加一个集合中的所有元素// System.out.println(c1.addAll(c2));//boolean containsAll(Collection c) :包含所有的元素算包含...//  System.out.println(c1.containsAll(c2));//boolean removeAll(Collection c):删除集合中的所有元素, (删除一个算删除,还是删除所有):删除一个算删除(必须同时都被包含进去)// System.out.println(c1.removeAll(c2));// boolean retainAll(Collection c):A集合对B集合求交集, boolean的返回值是什么意思,交集的元素是保存在A中还是B中/*** A集合堆B集合求交集,交集的元素存储在A集合中,然后返回值的意思: 看A集合的元素是否有变化(之前的元素和现在交集的元素进行对比)*/System.out.println(c1.retainAll(c2)); //c1集合对c2集合取交集System.out.println(c1);System.out.println(c2);System.out.println("-------------------------------------------");//使用Colllection存储5个学生(姓名,年龄,性别),然后将Collection进行遍历,获取出来每一个学生的信息!//创建一个Collection集合对象Collection c = new ArrayList() ;//创建5个学生Student s1 = new Student("宋江",45,"男") ;Student s2 = new Student("李逵",35,"男") ;Student s3 = new Student("武大郎",35,"男") ;Student s4 = new Student("西门庆",30,"男") ;Student s5 = new Student("吴用",40,"男") ;//存储集合中c.add(s1) ;c.add(s2) ;c.add(s3) ;c.add(s4) ;c.add(s5) ;//  Object[] toArray():将集合转换成了对象数组Object[] objs = c.toArray();//数组存储的每一个数据类型 Object obj = new Student() ; //向上转型//遍历数组for(int x = 0 ; x < objs.length ; x ++){//System.out.println(objs[x]) ;//getXXX()---->Student类的方法Student student = (Student) objs[x]; //向下转型System.out.println(student.getName()+"---"+student.getAge()+"---"+student.getGender());}}
}

1.List

1.List集合

List集合
ArrayList底层数据结构是数组,查询快,增删慢通过arr[索引值]:查询到某个元素存储null元素---->线程角度:   线程不安全的类,实现不同步的  ----->执行效率高特点:扩容机制:1.5倍的方式扩容Integer[] arr = {11,22,33,44,55} ;添加和删除元素:需要判断在33这个元素后面新的元素,需要新建数组,长度是以前数组长度+1判断加入的元素是否33元素33以前,按照以前的元素在新的数组进行存储33,继续存储33以后的,加入88元素(给33以后的元素后面插入新的元素)public ArrayList():无参构造方法:默认容量是10ArrayList扩容机制public ArrayList(int initialCapacity):初始容量为空,指定初始容量大小public ArrayList(int initialCapacity) {//10,20if (initialCapacity > 0) {10this.elementData = new Object[initialCapacity];//创建数组对象elementData} else if (initialCapacity == 0) {this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}}public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;}private void ensureCapacityInternal(int minCapacity) {//最小容量ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));}private void ensureExplicitCapacity(int minCapacity) {modCount++;  /protected transient int modCount = 0;:ArrayList父类中 默认0开始,统计变量// overflow-conscious codeif (minCapacity - elementData.length > 0)grow(minCapacity); //调用扩容方法}//扩容方法private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1); //右移动1位    //将左边的数据除以2的移动次幂  1/2if (newCapacity - minCapacity < 0)newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity);}//计算最终容量大小private static int calculateCapacity(Object[] elementData, int minCapacity) {if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {return Math.max(DEFAULT_CAPACITY, minCapacity);}return minCapacity;}Vector集合:底层数据结构是数组,查询快,增删慢线程角度:线程安全的类----同步的方法---->执行效率低单线程程序中.考虑集合默认都会使用 ArrayList,多线程环境集合---->Vector集合LinkedList底层数据结构是链表,查询慢,增删快线程角度:线程不安全的类---->不同步---->执行效率高特有功能:addFirst()removeFirst()getFirst()xxxLast()应用场景:模拟栈结构特点:先进后出如果没有明确要求使用什么(List)集合的时候 ,默认都是用ArrayList

List接口继承Collection
1.List集合特点:有序(存储元素和取出元素一致)允许元素重复
2.具备Collection相关的功能Object [] toArray()Iterator iterator()
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():列表迭代器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("hello") ;list.add("world") ;list.add("world") ;list.add("world") ;list.add("javaEE") ;list.add("javaEE") ;// void add(int index,Object element):在指定的索引处插 入元素list.add(1,"高圆圆");//Object get(int index):获取指定位置处的元素 :返回的被获取到的元素内容System.out.println(list.get(1));//  Object remove(int index):删除指定位置处的元素,返回被删除的元素System.out.println(list.remove(2));System.out.println("---------------------------------------");//Object set(int index,E element):修改指定位置处的元素(替换)System.out.println(list.set(1,"赵又廷"));System.out.println(list);}
}

2.迭代器

Collection的迭代器:集合的专有遍历方式Iterator iterator():返回值类型接口类型,需要返回的子实现类对象
Iterator接口:1）boolean hasNext():判断迭代器中是否存在下一个元素2）Object next():  获取下一个可以遍历的元素3）给Collection中存储String类型,遍历出来

public class CollectionTest {public static void main(String[] args) {//创建集合对象Collection c = new ArrayList() ; //List接口的子实现类 (重复元素)//添加元素c.add("hello") ;c.add("world") ;c.add("javaee") ;//获取Collection的迭代器Iterator iterator()Iterator it = c.iterator();//如果现在明确存储了3个元素,以后这些数据可能数据库获取的一个列表集合数据,一般while循环while(it.hasNext()){//判断迭代器中有下一个元素//才获取Object obj = it.next();// Object obj = new String("hello") ...String str = (String) obj;//向下转型System.out.println(str+"----"+str.length());}}
}

3.泛型

jdk5以后新特性:泛型<E/T>泛型的格式:<引用数据类型>模拟数组创建的时候,就已经明确了数据类型举例://   String[] array = {"hello","world","java",100}创建集合对象的时候,明确了集合中存储的数据类型<>
格式：集合类型<引用数据类型>  集合对象名 = new  子实现类<引用数据类型>() ;
泛型的好处:1)将运行时期异常提前了编译时期2)避免了强制类型转换3)提高了程序安全性

public class GenericDemo {public static void main(String[] args) {//创建Collection集合对象Collection<String> c = new ArrayList<String>() ; //new XXX<数据类型>: jdk7以后泛型推断c.add("hello") ;c.add("高圆圆") ;c.add("你好吗") ;// c.add(100) ;//获取迭代器Iteratr<E>是集合中存储的泛型是一致的Iterator<String> it = c.iterator();while(it.hasNext()){//获取String字符串的同时,还要获取长度String str = it.next();System.out.println(str+"---"+str.length());}}
}

4.List集合的遍历方式

List集合的遍历方式1）Object[] toArray()2）Iterator iterator()3）Object get(int index):获取指定位置处的元素    + int size():一种新的集合遍历方式4）ListIterator<E> listIterator():列表迭代器  :List集合专有遍历方式ListIterator:特有功能:boolean hasPrevious():是否有上一个元素可以迭代Object previous():获取上一个元素5）增强for   DK5以后 提供了增强for循环,替代集合中迭代器去遍历集合使用的(优先在集合中使用)格式:for(存储的引用数据类型 变量名: 集合/数组对象){ //集合使用居多,数组一般都是使用普通for使用变量名即可}注意事项:当前集合对象不能为空 null :foreach语句:增强for它本身就是获取迭代器了,就会出现空指针异常

public class ListTest {public static void main(String[] args) {//创建List集合对象List<String> list = new ArrayList<>() ;//添加元素list.add("hello");list.add("world");list.add("java");list.add("android");//Object get(int index):获取指定位置处的元素    + int size():一种新的集合遍历方式//size()+get(int index)集合for(int x = 0 ; x < list.size() ; x ++){String s = list.get(x);System.out.println(s+"---"+s.length());}System.out.println("-----------------------------------------------");//List集合存储Student对象并进行遍历(学生:姓名,年龄)List<Student> stuList = new ArrayList<>() ;//JDK7以后 泛型推断:自动的和前面的泛型类型一致!//创建3个学生Student s1 = new Student("张佳宁",31) ;Student s2 = new Student("迪丽热巴",29) ;Student s3 = new Student("张俊杰",20) ;//添加到列表中stuList.add(s1) ;stuList.add(s2) ;stuList.add(s3) ;//遍历//方式1:Object[] toArray()Object[] objs = stuList.toArray();for(int x = 0 ; x < objs.length ; x ++){Student s = (Student) objs[x];System.out.println(s.getName()+"----"+s.getAge());}System.out.println("--------------------------------------");//方式2:Collection的迭代器Iterator<Student> it = stuList.iterator();while(it.hasNext()){Student s = it.next() ;System.out.println(s.getName()+"---"+s.getAge());// System.out.println((it.next().getName()+"---"+(it.next().getAge())));// next()只能使用一次,不能多次使用 //错误的用法}System.out.println("-------------------------------------");//方式3:size()+get(int index)for(int x = 0 ; x < stuList.size() ; x ++){Student s = stuList.get(x);System.out.println(s.getName()+"----"+s.getAge());}System.out.println("-----------------------------------------");//方式4：正向遍历:ListIterator<E> listIterator():列表迭代器  :List集合专有遍历方式ListIterator<Student> lit = stuList.listIterator();/*** ListIterator extends Iterator{}** class ArrayList{*  List具体ArrayList子实现类重写了Iterator listiterator(){*      return new ListItr(0) ;*  }*          private class ListItr extends Itr implements Iterator{*                      //具备hasNext()*                      //next()*          }*  }*/while(lit.hasNext()){Student student = lit.next();System.out.println(student.getName()+"---"+student.getAge());}System.out.println("-----------------------------------------");//逆向遍历:前提:必须有正向遍历//ListIterator<E> listIterator()//ListIterator:特有功能://boolean hasPrevious():是否有上一个元素可以迭代//Object previous():获取上一个元素while(lit.hasPrevious()){Student student = lit.previous();System.out.println(student.getName()+"---"+student.getAge());}}
}public class Student {private String name ;private int age ;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}public void setAge(int age) {this.age = age;}
}

public class ForeachDemo {public static void main(String[] args) {//创建List集合List<String> list = new ArrayList<>() ;list.add("hello") ;list.add("world") ;list.add("javaee") ;/* for(String s:list){//替换迭代器使用//如果存在world元素,添加一个android元素//System.out.println(s);if("world".equals(s)){list.add("android") ;//出现并发修改异常}}System.out.println(list);*/list = null ;if(list!=null){for(String s:list){//获取迭代器System.out.println(s+"---"+s.length());}}else{System.out.println("当前集合对象为null了");}}
}

1）并发修改异常

需求:通过List集合ArrayList集合对象,如果当前集合中存在"world"元素,那么就给集合中添加一个"javaEE"元素,最后将集合中的所有元素进行遍历!举例:List集合现在就存有三个元素"hello""world""java"
java.util.ConcurrentModificationException:并发修改异常集合在使用迭代器会经常出现的问题:并发修改异常,当集合的元素正在被迭代器进行遍历,那么集合对象是不能够对元素进行增加或者删除 (一个线程正在遍历,一个线程在修改元素)解决方案:1)要么就是迭代器去遍历集合的元素,迭代器去添加元素  :列表迭代器才具备添加的动作2)要么集合遍历,集合添加

public class ListTest2 {public static void main(String[] args) {//创建List集合对象List<String> list = new ArrayList<>() ;//给添加元素list.add("hello") ;list.add("world") ;list.add("javaee") ;//使用迭代器遍历//Iterator iterator()/*  Iterator<String> it = list.iterator();  //"hello","world","javaee"while(it.hasNext()){String s = it.next() ;//"hello","world","javaee"//判断if("world".equals(s)){list.add("javaEE") ;//集合对象添加的元素,迭代器不知道}}System.out.println(list);*///解决方案1:  1)要么就是迭代器去遍历集合的元素,迭代器去添加元素  :列表迭代器才具备添加的动作//ListIterator//void add(E e)/*ListIterator<String> lit = list.listIterator();while(lit.hasNext()){//获取String s = lit.next();//判断是否存在"world"元素if("world".equals(s)){//列表迭代器添加lit.add("javaEE");}}*///方案2:要么集合遍历,集合添加//size()+get(int index)for(int x = 0 ; x < list.size(); x ++){String s = list.get(x);if("world".equals(s)){//将常量放前面,防止出现NullPointerExceptionlist.add("javaEE");}}System.out.println(list);}
}

5.List去重

1）方式1:新建空集合思想

方式1:新建空集合思想存储字符串类型并保证集合的元素唯一!List<String>集合中Collection/List--->contains(Object o)底层依赖于Object的equals方法而List现在存储的是String类型,本身重写Object的equals,所以比较的是内容是否相同

public class ListTest2 {public static void main(String[] args) {//创建List集合List<String> list = new ArrayList<>() ;//现在给集合中添加重复的字符串数据list.add("hello") ;list.add("hello") ;list.add("world") ;list.add("javaEE") ;list.add("world") ;list.add("javaEE") ;list.add("android") ;list.add("android") ;list.add("ios") ;//新建一个空的集合ListList<String> newList = new ArrayList<>() ;//遍历以前的集合for(String s :list){//使用新集合判断,不包含这个元素,说明该元素没有重复,就可以添加if(!newList.contains(s)){newList.add(s) ;}}//遍历新的集合for(String s:newList){System.out.println(s);}}
}

2）方式2:利用选择排序的思想去完成

 选择排序的思想:使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前方法.依次这样比较,1角标,2角标...List集合---集合列表角标从0开始遍历当前集合然后使用0角标对应的元素依次和后面对应的元素进行比较,如果后面的元素和前面的相同了,那么将后面的元素删除掉角标--

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）List存储自定义对象

List<Student>存储自定义对象 怎么去重?Student s1 = new Student("高圆圆",42) ;Student· s2 = new Student("高圆圆",42) ;成员信息如果一致,认为是同一个人,需要使用List集合去重!
1）方式1:新建集合思想contains(Object)方法依赖于Object的equals方法,所以集合存储的类型所在的类必须重写equals方法,否则默认使用Object的equals方法比较的地址值是否相同!
2）方式2:使用选择排序思想 将List<Student>存储的重复的学生对象进行重写!

public class ListTest4 {public static void main(String[] args) {//创建一个List集合List<Student> list = new ArrayList<>() ;//创建一些学生对象:有重复的成员信息Student s1 = new Student("高圆圆",42) ;Student s2 = new Student("高圆圆",42) ;Student s3 = new Student("刘诗诗",39) ;Student s4 = 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 student:newList){System.out.println(student.getName()+"----"+student.getAge());}}
}public class Student {private String name ;private int age ;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}public void setAge(int age) {this.age = age;}@Override                               //重写equalspublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name.equals(student.name);}@Overridepublic int hashCode() {int result = name.hashCode();result = 31 * result + age;return result;}
}

2.Vector

Vector集合特有功能:1）添加public void addElement(Object obj):在vector对象的末尾添加元素  ------> 一直使用的add(Object e)2）删除public boolean removeElement(Object obj):删除元素3）获取功能public Object elementAt(int index):获取指定位置的元素---->类似于  public Object get(int index)public Enumeration<E> elements() :Vector集合的专有遍历方式---->类似于   Iterator literator()接口boolean hasMoreElements():判断是否有更多的元素可以迭代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(); //相当于Iteratorwhile(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());}}
}
### 插入排序```markdown
插入排序   时间复杂度:O(N^2)核心思想:使用1角标对应的元素进行和0角标比较如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较依次这样比较....Integer类:包含了int类型的值:Integer实现自然排序(默认升序排序)public int compareTo(Integer anotherInteger) {      //  8  34return compare(this.value, anotherInteger.value);8,34}8          34public static int compare(int x, int y) {  //提高程序的执行效率return (x < y) ? -1 : ((x == y) ? 0 : 1);}

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);}//插入排序/*---方式1---*/private static void insertSort(Integer[] arr) {//定义一个变量jint j ; //j记录当前角标的变化//定义变量 : p:表示一个比较次数 p=1,2,3,4,5 (每一移动的元素的位置)for(int p = 1 ; p < arr.length ; p ++ ){ //比较次数     p=2//定义临时变量tempInteger temp = arr[p] ;    //temp = 8;          temp = 64//开始比较for(j = p ; j>0 && temp.compareTo(arr[j-1])<0; j-- ){  // j= 1 ; 1>0&& 8 < 34   j-- : j= 0//j=2 ; 2>0 && 64 < 32//数据移动arr[j] = arr[j-1] ;}//确定temp的位置:8的位置   64的位置:p=2arr[j] = temp ;         // 没有移动}}/*---方式2---*/public static void insertion(int[] arr) {int current ;int Index ;for(int i = 1 ; i < arr.length ; i ++) {current = arr[i] ;Index = i - 1 ;while(Index >= 0 && current < arr[Index] ) {arr[Index+1] = arr[Index] ;Index-- ;}arr[Index+1] = current ;}}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]+", ");}}}
}

第四周 Java语法总结_内部类_常用类_getclass_toStrong_equals_clone_Scanner_String_StringBuffer_Integer_集合_插入排序相关推荐

1. Lesson15_内部类和常用类

   Lesson15_内部类和常用类 回顾 简单工厂 *工厂方法 *抽象工厂模式 创建对象,把创建对象和使用对象进行解耦. 对象使用者只需要和工厂打交道即可. 如果有了新的对象类型产生,只需要修改工厂即可 ...

2. java map常用类及其方法_Day50.Map类常用的方法 -Java常用类、集合#、IO

   Day50.Map类常用的方法 -Java常用类.集合#.IO Day50.Map类常用的方法 -Java常用类.集合#.IO Map类常用的方法 . 总结: 常用方法 添加: put(Object ...

3. Java实用教程笔记 内部类与异常类

   内部类与异常类 Review Note 只有我能用,不希望别人用(内部类的基本思想) .class文件的生成个数 匿名类 匿名类都是一次性的(当前这一次,以后不能用) Conclusion Revie ...

4. 面试准备——Java回顾：高级编程(多线程、常用类、集合、泛型、IO流、反射、动态代理、新特性)

   多线程 程序.进程.线程 程序:完成特定任务.用某种语言编写的一组指令的结合,一段静态的代码,静态对象: 进程:程序的一次执行过程,即正在执行的程序: 线程:进程可细化为线程,是一个程序内部的一条执行 ...

5. java学习笔记（十一）常用类、反射、垃圾回收

   常用类: System类代表当前java程序的运行平台,Runtime类代表当前java程序的运行时环境. String代表一个不可变的字符串,StringBuffer和Stringbulider代表 ...

6. java内部枚举类_内部类和枚举类

   内部类: 内部类的定义 : 在一个类的内部又定义了一个类,里面的这个类就是内部类. 内部类可以定义在外部类的成员位置(与成员变量的位置相同)或局部位置(意思是,把类写在外部类的方法里面). 什么时候使 ...

7. baseresponse响应类_内部类、响应类Response、序列化基类、反序列化、全局局部钩子...

   一.内部类 1.概念:将类定义在一个类的内部,被定义的类就是内部类 2.特点:内部类及内部类的所以名称空间,可以直接被外部类访问的 3. 应用:通过内部类的名称空间,给外部类额外拓展一些特殊的属性(配 ...

8. java里SQL insert操作的语法_Java含个人总结语法:JDBC,学生表，实体类，集合，增删改查，注入，预处理【诗书画唱】...

   create table denglu( uname varchar(30), upwd varchar(30) ) insert into denglu values('诗书','123') ins ...

9. C#_文件读写常用类介绍

   首先要熟悉.NET中处理文件和文件夹的操作.File类和Directory类是其中最主要的两个类.了解它们将对后面功能的实现提供很大的便利.     本节先对和文件系统相关的两个.NET类进行简要介绍 ...

最新文章

1. Python链接MySQL
2. 身体容易缺少的微量元素
3. arcgis标注牵引线_解析ArcGis的标注（三）——标注的放置 与 转注记修改
4. mybatis3.1-[topic-16-17]-映射文件_增删改查_insert_获取自增主键的值
5. fs和php的区别,优缺点评测飞科fs318和fs360有啥区别？哪个好？真实评测体验曝光...
6. Java8新特性-Lambda表达式
7. 行为决策学入门书籍推荐《别做正常的傻瓜》
8. 可编辑div的一些方法总结（二）自定义空格和回车事件
9. 【python】7-10 将输入的字符串中的字符头尾间隔输出（PTA）
10. 数据库字段属性的详解
11. 【环境问题】基础Web环境搭建问题记录2——Failed to obtain JDBC Connection;
12. 看看外贸业务员到底是干什么的？
13. 深入理解Linux多线程
14. 每天学点统计学——平均
15. 【新手向】最大团问题和最大独立子集的懒人算法(随机化)
16. batik详解(5) 转载
17. html5+CSS+JavaScript学习笔记（小甲鱼）
18. 图像搜索引擎搭建 VP-Tree 以图搜图
19. .replaceWith（）只能工作一次
20. 今日科技联播：程维确认滴滴上半年亏损40亿元，子弹短信未来六个月将烧10亿拉新...

热门文章

1. C Primer Plus(第5版)中文版
2. duilib实战1-模仿百度网盘登录界面
3. 层次分析，critic以及topsis
4. 窝囊少爷 第二章 冰火两重天
5. iOS 调用icloud drive的使用
6. XK3190 A12 E称重控制器RS232采集称重数据过程
7. 图片标签img中alt与title的区别
8. C语言系列：2、数据类型、运算符和表达式
9. Python 实现淘宝秒杀
10. 一篇文章让你了解什么是反爬