[Java知识库]week04

day15

1.局部内部类的特点

局部内部类,它的书写位置,在外部类的成员方法中的定义类
局部内部类可以访问外部类的成员变量包括私有
在外部类的局部位置,访问内部类的成员方法,创建当前局部内部类对象来访问
 //定义一个外部类
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.局部内部类的面试题

☆☆☆面试题:
     局部内部类访问局部变量的时候,此时局部变量应该注意什么?  (JDK7/JDK8),为什么要加入final关键字呢?
如果此时java环境是JDK7,局部内部类访问局部变量时,此时该变量必须手动显示加入final关键字
环境是JDK8环境,此时局部内部类访问局部变量,局部变量不需要显示给出final,jvm做优化,通过反编译工具查看局部内部类
         外部类名$内部类名.class
             当前局部变量----->已经加入final关键字
             加入final关键字,此时变量是常量
         /**
             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修饰
*/

class  Outer2{
    public  void  method(){
        int num  =  20; //局部变量,JDK8以后,不需要加入final
              class  Inner2{
                  public  void  show(){
                      System.out.println(num);
                  }
              }
                 //创建Inner2类对象
                   Inner2 inner2  =  new  Inner2();
                    inner.show();
                  }
              }
//测试类
public class OuterDemo2{
    public static void main(String[]  args){
        //创建Outer2对象
        Outer2.outer  =  new  Outer2();
        outer2.method();
    }
}
          

3.匿名内部类

匿名内部类:没有名字的内部类,一般在我们局部位置使用!
格式:匿名内部类它是内部类的一种简化格式
    new  类名(可以是抽象类,也可以是具体类)或者是接口(){
         重写功能
    };
匿名内部类的本质:
    继承了该类或者是实现了该接口的子类对象
    
//定义一个接口
interface  Inner{
        void  show();  //public  abstract修饰(可以省略)
        void  show2();
    }
//外部类
class  Outer3{
    //定义一个成员方法
    public  void method(){
        //给匿名内部类起一个名字
        Inter  i  =  new  Inter(){
            public void show(){
                System.out.println("show  Inter");
            }
            public void show2(){
                System.out.println("show2  Inter");
            }
        };
        i.show();
        i.show2();
    }
}
//测试类
public class OuterDemo3{
    public static  void  main(String[]  args){
        //创建Outer3类对象
        Outer3  outer3 =  new  Outer3();
        outer.method();
    }
}

4.Object类的toString方法以及equals方法

public  String   toString():对象的字符串表现形式,结果应该简明扼要,易于读懂的表达式(成员信息表达式)

需要建议子类重写这个方法,否则如果直接输出对象名称,打印出来是一个"地址值",没有意义
    Student  s  =  new  Student("张三",20,"男");
   如果不重写object的toString(),直接输出s,----->等价于 s.toString()------>
       this.getClass().getName()+"@"+Integer.toHexString(this.hashCode())
    重写tostring()--->alt+ins---->toString()
       类名{[name="张三",age=20,sex="男"]}
public  boolean  equals(Object  obj)
    ==和equals
    ==:如果连接的基本数据类型:比较数据值是否相同
    ==:如果连接的引用数据类型:比较的是对象的地址值是否相同
        
        Student  s1  =  new  Student("张三",20,"男");
        Student  s2  =  new  Student("张三",20,"男");
                    s1.equals(s2);------->//false
     equals:如果不重写Object的equals,它默认比较的是两个对象的地址值是否相同
           return(this==obj);
    建议子类重写equals方法的同时,还需要重写hashCode()(对象不同,哈希码值是不相同的)
     alt+ins----->equals  and  hashCode()---->idea  default
        重写之后:  s1.equals(s2);---------->true
   String类型---底层已经对Object的equals重写了,所以String的equals就比较的是字符串内容是否相同

5.获取类的字节码文件对象的方式:-------->Class class 包名.类名

Object类的getClass()方法
任意java类型的class属性:  String.class  Student.class...
反射中使用:Class.forName("包名.类名(类的全限定名称)");

6.针对静态成员内部类,外部类访问静态成员内部类的成员方法

外部类名.内部类名  对象名  =  new  外部类名.内部类名();

day16

1.Object类的克隆方法(clone)

克隆方法
protected  Object   clone()   throw CloneNotSupportedException:创建对象并返回该对象的副本
 这个方法会抛出一个异常,throws:表示的是可能出现异常,针对调用者必须进行处理
要使用clone方法,当前某个对象所在的类必须实现"标记接口"Cloneable(没有字段(成员变量)),也没有成员方法,实现这个接口,那么就可以使用Object的clone()方法\
 
 练习题:
public  class ObjectDemo{
    public static void main(String[] args) throws CloneNotSupporedException{
        //创建学生对象
        Student  s1  =  new  Student("张三",20);
        System.out.println(s1);
        System.out.println(s1.getName()+"---"+s1.getAge());
        System.out.println("-----------------------------");
        
        //调用克隆方法clone()
        Object  obj  =  s1.clone();//(浅克隆:将s1地址值赋值给Object)
        //向下转型
        Student  s2  =  (Student)obj;
        System.out.println(s2);
        System.out.println(s2.getName()+"-----"+s2.getAge());
        
        System.out.println("-------------------------------");
        
        //传统方式
        Student  s3  =  s1;
        System.out.println(s3.getName()+"------"+s3.getAge());
}

//定义一个学生类
public  class  Students implements   Cloneable{
    private  String  name;
    private  int age;
    public  String  getName(){
        return  name;
    }
    public  void  setName(String name){
        this.name  =  name;
    }
    public  int  getAge(){
        return  age;
    }
    public  void  setAge(int age){
        this.age  =  age;
    }
    public  Student(){
        
    }
    public  Student(String name,int age){
        this.name =  name;
        this.age  =  age;
    }
    @Override
    public  String   toString(){
        return "Student{"+
               "name=''"+name+'\''+
            ", age="  +age +
            '}';
    }
    @Override
    protected  Object  clone()  throws  CloneNotSupportedException{
          return  super.clone();
    }
}

2. String

java.lang.String:代表的字符串
字符串是一个常量,一旦被赋值,其值(地址值)不能被更改
推荐使用的方式:
    String  变量名 =  "xxxx";   //xxxx代表的当前String的实例
String类常用的功能:
    获取功能:int  length():获取字符串长度
      
构造方法:
public String():空参构造,空字符序列
    
public   String(byte[] bytes):将一个字节数组构造成一个字符串,使用平台默认的字符集(utf-8:一个中文对应三个字节)解码
        编码和解码---保证字符集统一
        编码:将一个能看懂的字符串---->字节
        解码:将看不懂的字节---->字符串
public  String(byte[] bytes,字符集):使用指定的字符集,将字节数组构造成一个字符串
            
public String(byte[]  bytes,int  offset,int length):将指定的部分字节数组转换成字符串
                     参数1:字节数组对象    参数2:指定的角标值   参数3:指定长度

public  String(char[]  value):将字符数组构造成一字符串
                         
public  String(char[]  value,int offset,int count):将部分字符数组转换成字符串
                         
public  String(String original):构造一个字符串,参数为字符串常量
                         

3. String面试题

☆☆☆面试题
   在数组中有没有length方法,在String类中有没有length方法,在集合中有没有length方法?
        数组中没有length方法,length属性
        String类中又length()
        集合中没有length(),---->size()获取元素数

☆☆☆面试题:
  String s1  = "hello";
  String  s2  =  new  String("hello");
在内存中分别创建了几个对象?
    第一个:创建了一个对象,直接在常量池创建,开辟常量池空间
    第二个:创建了两个对象,一个在堆内存中开辟空间,一个指向常量池(不推荐)
        
public  class StringDemo{
    public static  void  main(String[]  args){
        String  s1  =  "hello";
        String  s2  =  new  String("hello");
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));    //只管内容相同
    }
}

4. String类型的判断功能

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

    

5. String类的常用的转换功能(重点)

String类的常用的转换功能:
//编码的过程:将字符串转换成字节数组
   byte[]  getBytes(){}  :将字符串转换成字节数组(编码)
                       如果方法为空参,使用平台默认的编码集进行编码(utf-8:一个中文对应三个字节)
   byte[]  getBytes(String  charset):使用指定的字符集进行编码
       
//解码的过程:将看不懂的字节数---->String
   String(byte[] bytes){}:使用默认字符集进行解码
           
   String(byte[] bytes,指定字符集)
     编码和解码必须要保证字符集统一
    
Arrays静态功能:  Arrays.toString
public static String toString(int/byte/float/double..[] a):将任意类型的数组------>String
    
    public char[]  toCharArray():将字符串转换成字符数组
    public String  toString():返回自己本身---"当前字符串的内容"
    public String   toUpperCase():将字符串转换成大写
    public String  toLowerCase():将字符串转换成小写

6. String类的获取功能

int length():获取字符串长度

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

7.字符串其他功能

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

8.字符串练习

import java.util.Scanner;
public class StringTest{
    public  static  void  main(String[]  args){
        Scanner sc =  new  Scanner(System.in);
        System.out.println("请您输入一个字符串(大小写字母):");
        String  line =  sc.nextline();
        //将字符串中的第一个截取出来subString(0,1)
        String  s1  =  line.subString(0,1);
        //将s1的结果转换成大写
        String  s2  =  s1.toUpperCase();
        //从该字符串中第二个字符开始:默认截取到末尾
        String s3  =  line.substring(1);
        //将s3的结果转换成小写
        String  s4  =  s3.toLowerCase();
        
        //将s2和s4的功能通过concat进行拼接功能
        String result  =  s2.concat(s4);
        System.out.println(result);
    }
}

9.StringBuffer

StringBuffer:字符串缓冲区--->类似于String,但是不一样(可变的字符序列)
    
StringBuilder:和StringBuffer具有相互兼容的API,它是线程不安全的类--->不同步--->执行效率高

单线程程序中:jvm在进行编译的时候,使用StringBuilder去替换StringBuffer
    
StringBuffer的构造方法
public StringBuffer():空参构造,创建一个空字符序列的字符串缓冲去(推荐)
    
public StringBuffer(int capacity):构造一个字符串缓冲区对象,指定容量大小
    
public  StringBuffer(String  str):指定字符串序列,长度加上初始容量16(总容量)
    
获取功能:
public  int  length():获取字符数(长度)
    
public int capacity():获取字符串缓冲区容量

day17

1. String类的遍历

将字符串每一个字符分别输出
可以使用String类的获取功能:charAt(int index)---->char
    
public  class  StringTest{
    public  static  void main(String[]  args){
        String  str  = "helloJavaEE";
        //循环:利用String类的length():获取字符串长度 + charAt(int index)
        for(int x = 0;x<str.length();x++){
            System.out.println(str.charAt(x));
        }
        
        System.out.println("----------------------");
        
        //使用String类的转换功能,   String------>字符数组toCharArray()------>char[]
        char[]  chs =  str.toCharArray();
        for(int  x=0;x< chs.length;x++){
            char  ch  =  chs[x];
            System.out.println(ch);
        }
    }
}

2. String 类的使用:将数组转换成String

/**
 * 已知一个数组,静态初始化,将数组拼接成String
 * 定义一个将数组转换成String功能,返回值就是String  [元素1,元素2,元素3....]
 * 拼接:  + 拼接符号
 *        concat():拼接功能
 * */
public class StringTest2 {
    public static void main(String[] args) {
        int[]  arr  = {11,22,33,44,55};
        String str =  array2String(arr);
        System.out.println(str); //+--->使用Stringconcat功能完成
    }
    /**
     * 定义一个将数组转换成String类型的功能
     * 两个明确
     *   1).明确返回值类型:String
     *   2).明确参数类型以及参数个数:一个参数,int类型的数组
     * */

    private static String array2String(int[] arr) {
        //定义一个空字符串
        String  result =  "";
        //拼接左中括号
        result  += "[";
        //遍历arr数组,获取每一个元素
        for(int x =  0;x<arr.length;x++){
            //判断是否是最大角标
            if(x== arr.length-1){
                result  +=  arr[x];
                result  +=  "]";
            }else{
                //拼接逗号和空格
                result  += arr[x];
                result  += ", ";
            }
        }
        return  result;
    }
}

3.字符串的反转功能

/**
 * 键盘录入字符串,将字符串进行反转(使用功能改进)String 转换功能
 * StringBuffer:有反转功能
 *
 * */
public class StringTest3 {
    public static void main(String[] args) {
        Scanner  sc  =  new Scanner(System.in);
        System.out.println("请您输入一个字符串:");
        String  line  = sc.nextLine();

        //调用功能
        String  result   =   reverse(line);
        System.out.println(result);
    }
    /**
     * 定义字符串反转功能
     * @Parma  s  将指定的字符串进行反转
     * @return  返回需要的反转的字符串值
     * */
    private static String reverse(String s) {
        //定义一个结果变量
        String result =  "";
        //将字符串转换成char[]
        char[]  chs = s.toCharArray();  //转换功能
        for(int  x = chs.length-1;x>=0;x--){
            result  +=  chs[x];
        }
        return   result;
    }
}

4.判断字符串是否为对称字符串

5. StringBuffer的添加功能

StringBuffer:线程安全的(执行效率低):字符缓冲区:里面存储的字符序列
添加功能:
 StringBuffer  append(任何类型):将内容追加到字符串缓冲区(在字符串缓冲区的最后一个字符序列的末尾追加)
                       返回值是字符串缓冲区本身
public  StringBuffer  insert(int offest,String  str):插入:在指定位置处插入指定的内容

6. StringBuffer的删除功能

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

7. 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 buffer = new StringBuffer("world") ;
String str = new String(buffer) ;
//第二种方式:StringBuffer的toString方法

8. StringBuffer的特有功能:反转功能(reverse)

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

9. StringBuffer的截取功能(substring)

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

10.☆☆☆面试题:StringBuffer和数组的区别

共同点:都是容器,都可以存储任意类型的元素,可以存储基本类型,也可以存储引用类型
数组:只能存储同一种数据类型容器
    数组的最大的特点:长度固定
    静态初始化  int[]  arr =  {元素1,元素2,元素3...};
    动态初始化  int[]   arr =  new int[长度];
    String  strArray =  {"xx","xx","xx"};
StringBuffer:支持可变的字符序列,里面可以存储不同类型的元素  长度是可变的
    append(int/char/double/float/Object/String)
    insnert(int offert,int/char/double/float/Object/String)
    一般情况:开发中将StringBuffer------>String

11. ☆☆☆面试题:StringBuffer,StringBuilder和String的区别

String :字符串是一个常量,一旦别赋值,其值不能更改,作为形式参数属于特殊的引用类型,形式参数的改变不会影响实际参数
    
StringBuffer:可变的字符序列,线程安全的类----同步的---执行效率低(多线程:同步锁)

StringBuilder:可变的字符序列,和StringBuffer具有相互兼容的api,单线程程序中(只考虑执行效率,不考虑安全问题),会使用StringBuilder替代StringBuffer,多线程环境中,要考虑安全问题只能使用StringBuffer

12.Integer

Integer:int类型的包装类类型(引用类型),包含了int类型的原始数据值

基本类型四类八种都有对应的各自的引用类型
需要基本类型和String类型之间转换:需要中间桥梁(基本类型对应的包装类类型)   int---->String
    
    整数类型    引用类型
      byte ---->Byte
      short---->Short
      int ----->Integer
      long----->Long
    
    浮点类型
     float ----->Float
     double----->Double
    
    字符类型
     char  ------>Character
    
    布尔类型
    boolean  ----->Boolean
    
进制的转换----->可以使用Integer静态功能
    
通过Integer得到int类型的取值范围
public  static String  toBinaryString(int i):将整数---->二进制的字符串
    
public static  String   toOctalString(int i):将整数---->八进制的字符串
    
public static String   toHexString(int i):将整数----->十六进制数据
    
public  static  final  int  MAX_VALUE:int的最大值
    
public  static  final   int  MIN_VALUE:int的最小值
    
Integer的构造方法
    Integer(int value):可以将int类型保证为Integer类型
    Integer(String  s)  throws  NumberForamtException:抛出一个数字格式化异常
       注意事项:当前字符串如果不是能够解析整数,就会出现数字格式化异常,s必须为数字字符串

13.自动拆装箱

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

14.Integer的内部缓存区_integerCache (low:-128,high:127)

public class IntegerTest {
    public static void main(String[] args) {
        Integer  i1  =  new Integer(127);
        Integer  i2  =  new Integer(127);
        System.out.println(i1==i2);  //false
        System.out.println(i1.equals(i2));  //true
        System.out.println("---------------------");

        Integer  i3  = 127;
        Integer  i4  =  new Integer(127);
        System.out.println(i3==i4);    //false
        System.out.println(i3.equals(i4));  //true
        System.out.println("-------------------------");

        Integer  i5 =  128;
        Integer  i6  =  new Integer(128);
        System.out.println(i5==i6);  //false
        System.out.println(i5.equals(i6));  //true
        System.out.println("--------------------------");

        Integer   i7  =  127;
        Integer   i8  =  127;
        System.out.println(i7==i8);    //true
        System.out.println(i7.equals(i8));  //true
        System.out.println("----------------------------");

        Integer  i9  = 128;
        Integer  i10  =  128;
        System.out.println(i9==i10);    //false
        System.out.println(i9.equals(i10));  //true
    }
}

15.Charcater

char类型的包装类类型
构造方法:  public Character(char value)
主要功能:
      public static boolean isUpperCase(char  ch):判断当前字符是否大写字母字符
      
      public static  boolean  isLowerCase(char  ch):是否为小写字母
          
      public  static  boolean  isDigit(char ch):是否为数字字符
          
      public  static  char  toLowerCase(char  ch):将字符转换成小写
          
      public static  char  toUpperCase(char ch):将字符转换成大写

16.日历类Calendar

java.util.Calendar
Calendar:提供一些诸如获取年,月,日中的日期等等字段值
静态功能,返回值是它本身     public static  Calendar  getInstance()
    
成员方法:
public int get(int  field):根据给定日历字段-----获取日历字段的值(系统的日历)
    
public abstract  void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量
    参数1:日历字段
    参数2:偏移量

17.date日期

Java.util.Date:表示特定瞬间,精确到毫秒,允许格式化和解析日期字符串
构造方法:
public  Date():当前系统时间格式
public Date(long date):参数为:  时间毫秒值----->Date对象(1970年1月1日)
    
Java.util.Date---->String  格式化过程
    
DateForamt:抽象类----提供具体的日期/格式化的子类:SimpleDateFormat
    
SimpleDateFormat:构造函数
public SimpleDateFormat():  使用默认模式
    
public SimpleDateFormat(String  pattern):使用指定的模式进行解析或者格式(推荐)
    参数:  一种模式
        表示年            "yyyy"
        表示月              "MM"
        表示月中的日期        "dd"
        一天中小时数          "HH"
        分钟数              "mm"
        秒数                "ss"
        
public Date parse(String sourse)throws   ParseException
如果解析的字符串的格式和public  SimpleDateFormat(String pattern)的参数模式不匹配的话,就会出现解析异常
        

18.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.format(date);  //使用textDate日期文本字符串

//String:日期文本字符串------>java.util.Date
//1.日期文本字符串
String  sourse   = "2021-7-29";//格式
//2.创建SimpleDateFormat对象
SimpleDateFormat   sdf2  =  new SimpleDateFormat("yyyy-MM-dd");//模式必须和String的格式一致,否则解析出错
//3.解析操作
Date  date2   =  sdf2.parse(sourse);//使用Date

19.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();

day18

1.Random类 (java.util.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)
    
产生随机数:
    MAth类的random方法    public  static double random();
    Random类:无参构造+成员方法     public Random():  +  public  int  nextInt(int n)
    

2.Math类(java.lang.Math)

public  static  int  abs(int a):绝对值方法
    
public static  double  ceil(double a):向上取整
    
public  static double  floor(double a):向下取整
    
public  static int  max(int a,int  b):获取最大值
    
public  static  int  min(int a,int b):获取最小值
    
public  static  double  pow(double  a,double  b):a的b次幂
    
public static double  random():随机数
    
public  static  long round(double  a):四舍五入
    
public  static  double sqrt(double  a):开平方根

MAth类中的功能都是静态的,里面构造方法私有化
工具类中的构造方法都是会私有化(自定义的工具类),提供对外静态的公共访问方法

3.BigDecimal类

小数要进行精确计算,还可以计算的同时保留小数点后的有效位数  Java提供的类:BigDecimal
构造方法:
public BigDecimal(String value):数字字符串
成员方法:
public  BigDecimal  add(BigDecimal  augend)  加
    
public BigDecimal subtract(BigDecimal subtrahend) 减
    
public BigDecimal multiply(BigDecimal multiplicand) 乘
    
public BigDecimal divide(BigDecimal divisor)  除
    
public BigDecimal  divide(BigDecimal  divisor,int  scale,int  roundingMode)
    参数1:商
    参数2:小数点后保留的有效位数
    参数3:舍入模式:四舍五入

4.List集合和set集合特点

List集合有序,存储和 取出一致的,可以允许元素重复
Set集合无序,存储和取出不一致,不允许元素重复(元素唯一)

5.Collection

面试题:集合和数组有什么区别?
1).长度区别
    数组:长度固定
    集合:长度可变
2).存储数据类型的区别
     数组:可以存储基本数据类型,也可以存储引用数据类型
     集合:前提条件:集合中加入泛型<>  只能存储引用类型   Collection<E>:泛型<引用类型>
3).存储元素的区别:
     数组:存储的元素必须为同一种数据类型
     集合:如果没有加入泛型  :就可以存储任意类型的元素(必须引用类型)
         
Collection:集合层次的根接口,一些集合允许元素重复(List),一些集合不允许元素重复(Set),一些集合有序(存储和取出一致)(List),一些集合无序(存储和取出的不一致)(Set)
JDK不提供次接口的任何直接实现:它提供了更具体的子接口的实现,如Set和List
    

6.Collection的基本功能

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

7.Collection的高级功能

添加:
boolean addAll(Collection  c):添加一个集合中的所有元素
    
boolean  containsAll(Collection c):包含一个集合中的所有元素
    
删除:    
boolean removeAll(Collection c):删除集合中的所有元素(删除一个算删除,必须同时都被包含进去)
    
boolean  retainAll(Collection c):A集合对B集合求交集,交集的元素存储在A集合中,然后返回值的意思:看A集合的元素是否有变化(之前的元素和现在交集额元素进行对比),如果有变化,返回true,没有变化,则返回false
    
Collection最基本的遍历功能,不属于集合的专有遍历
    Object[]   toArray():将集合转换成了对象数组

8.Collection的迭代器:集合的专有遍历方式

迭代器的本质:实现了Interator接口的子实现类对象(ArrayList的成员内部类)
Iterator  iterator():返回值类型接口类型,需要返回的子实现类对象
Interator接口:
     boolean hasNext():判断迭代器中是否存在下一个元素
     Object  next():  获取下一个可以遍历的元素
     

9.Collection集合进行遍历的方式

//方式1:j将Collection转换成Object[]  toArray(){}
Collection<String>  c  =  new  ArrayList<String>();
c.add("hello");
c.add("javaee");
c.add("javaweb");
//直接转换成对象数组
Object[]  obj  =  c.toArray();
//遍历数组
for(int x = 0; x< obj.length; x++){
    System.out.println(obj[x]);
}

//方式2:  获取Collection的Iterator迭代器(集合高效的遍历方式)
Collection<String>  c2  =  new  ArrayList<String>();
c2.add("hello");
c2,add("world");
c2,add("javaee");
Interator<String>  it  = c2.iterator();
while(it.hasNext()){
    String  str  =  it.next();
    System.out.println(str);
}

10.Iterator的原理

内部具备一个指针,当在第一次获取元素的时候,指针处在第一个元素前面的位置;当通过hasNext()判断,如果存在下一个可以迭代的元素,那么指针就会向下一个索引进行移动,并且next()获取前面的元素,依次这样操作,直到hasNext()为false的时候,没有元素了,指针就不会在移动;Interator是一个接口,具体的移动的操作是通过ArrayList的成员内部类Itr来进行实现

11.JDK5新特性:泛型<>

泛型的格式:
    <引用数据类型>
模拟数组创建的时候,就已经明确了数据类型
创建集合对象的时候,明确了集合中存储的数据类型<>
集合类型<引用数据类型>  集合对象名  =  new 子实现类<引用数据类型>();
泛型的好处:
    1).将运行时期异常提前了编译时期
    2).避免了强制类型转换
    3).提高了程序安全性

day19

1. List集合特点/功能

特点:有序(存储元素和取出元素一致)     允许元素重复
特有功能:
   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():  列表迭代器
 

2. List集合的遍历方式

Object[] toArray()
Iterator  iterator()
Object  get(int index):获取指定位置处的元素    +Int size(): 一种新的集合遍历方式
 <?>:任意类型包括Object   <? extends  E>   <? super E>  泛型高级:通配符   

3.并发修改异常

java.util.ConcurrentModificationException----->并发修改异常
    
集合在使用迭代器会经常出现的问题:并发修改异常
    当集合的元素正在被迭代器进行遍历,那么集合对象是不能够对元素进行增加或者删除(一个线程正在遍历,一个线程正在修改元素)
    
解决方法:
  1).要么就是迭代器去遍历集合的元素,迭代器去添加元素:列表迭代器才具备添加的动作
   2).要么集合遍历,集合添加

4.增强for循环

JDK五以后,提供了增强for循环,替代集合中迭代器去遍历集合使用的(优先在集合中使用)
格式:
  for(存储的引用数据类型  变量名: 集合/数组对象){
   //集合使用居多,数组一般都是使用普通for使用变量名即可
  }
  
注意事项:
   当前集合对象不能为空 null:foreach语句,增强for它本身就是获取了迭代器,就会出现空指针异常

5.List集合去重的方法

方法1.新建空集合思想
    存储字符串类型并保证集合的元素唯一    List<String>
    集合中Collection/List--->contains(Object 0)底层依赖于Object的equals方法,而List现在存储的是String类型,本身重写Object的equals,所以比较的是内容是否相同
    
方法2.条件:不重新新建一个List集合,利用选择排序的思想去完成
     选择排序的思想:使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前方法,依次这样比较,1角标,2角标...
     List集合---集合列表角标从0开始
     遍历当前集合
     然后使用0角标对应的元素依次和后面对应的元素进行比较,如果后面的元素和前面的相同,那么将后面的元素删除掉
         
List<>存储自定义对象,去重方法:
方式1.新建集合思想
    contains(Object)方法依赖于Object的equals方法,所以集合存储的类型所在的类必须重写equals方法,否则默认使用Objeect的equals方法比较地址值是否相同
    
方式2.使用选择排序思想,将List<>存储的重复的对象进行重写

6. Vector集合特有功能

添加:
public  void  addElement(Object  obj):在vector对象的末尾添加元素
    
删除:
public boolean removeElement(Object obj):删除元素
    
获取功能:
public  Object elementAt(int index):获取指定位置的元素  ------>类似于
public Object get(int index)

Vector集合的专有遍历方式    
public Enumeration<E>  elements()  :  -->类似于Iterator literator()

boolean  hasMoreElements():判断是否有更多的元素可以迭代
Object  nextElement()  获取元素

7.List集合的三个子实现类的特点

Collection
    List  最具体的子实现类ArrayList,LinkedList,Vector
List集合有三个子实现类
    1).ArrayList
        底层数据结构式数组结构,查询快,增删慢
        从内存角度考虑:线程不安全的,不同步的,执行效率高
        多线程:synchronized:同步的意思,解决线程安全问题
              sychronized(锁对象){  同步代码
                   共享数据;
               }
         解决线程安全问题,通过同步可以解决,效率低了
    2).LinkedList
         底层数据结构式链表结构,查询慢,增删快
         从内存角度考虑:线程不安全,不同步,执行效率高
    3).Vector
         一个线程安全的类,底层数据结构是数组,查询快,增删慢,线程安全的,同步,执行效率低

8.插入排序

核心思想:使用1角标对应的元素进行和0角标对比,如果前面元素大,向右移动,确定角标1对应的元素位置,再次使用2角标对应的元素依次和1和0的元素比较,依次这样比较...
Integer类:包含了int类型的值  ,Integer实现了自然排序(默认升序排序)
    
//插入排序练习    
public class InsertSortDemo {
    public static void main(String[] args) {
        //定义一个Integer数组,Integer实现的自然排序,元素按照升序默认排序
        Integer[]  arr  = {65,34,78,13,3,26};
        System.out.println("排序前:");
        printArr(arr);

        //定义一个功能
        insertSort(arr);
        System.out.println("排序后:");
        printArr(arr);
    }
    //遍历
    public  static  void  printArr(Integer[]  arr){
        System.out.print("[");
        for(int x =0;x <arr.length; x++){
            if(x==arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
    //插入排序
    private  static  void  insertSort(Integer[]  arr){
        int j;//定义一个变量j,记录当前角标的变化
        for(int y = 1; y< arr.length;y++) {
            Integer temp = arr[y];
            for (j = y; j > 0 && temp.compareTo(arr[j - 1]) < 0; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
        }
    }
}