第四周Java学习周总结

最新推荐文章于 2024-05-23 17:45:07 发布

zhangjinyan1

最新推荐文章于 2024-05-23 17:45:07 发布

阅读量188

点赞数

文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/zhangjinyan1/article/details/127936445

版权

11.14晨写

1.局部内部类访问局部变量，jdk7以前为什么加入final
局部内部类访问局部变量,局部变量必须使用final修饰;
在使用局部内部类对象在访问这个成员方法里面使用这个变量,当方法结束之后,保证这个变量不会立即消失,所以需要定义常量;
jdk8以及jdk8以后 jvm已经对这个局部变量优化 ,将final已经省略了!

2.匿名局部内部类的格式以及本质
匿名内部类的格式:
       new 类名或者一个接口名(){
           重写方法(){
               ...
           }
       }

匿名内部类的本质:就是继承该类(抽象类)或者是实现类了该接口的子类对象!

3.匿名内部类在开发中作为形式参数以及返回值的如何使用
//如果一个方法的形式参数是一个抽象类,那么传递实际参数需要当前这个类的子类对象
//一个方法的形式参数如果是一个接口,实际参数需要传递接口的子实现类对象
abstract class Person{
    public abstract void study();
}
class Demo{
    public void show(Person p){
        p.study() ;
    }
}

//调用Demo类中show方法
Demo d = new Demo() ;
d.show(new Person(){
    public void study(){
        //...
    }

}) ;

interface Inter{
    void inter() ;
}
class InterDemo{
    public void method(Inter inter){
        inter.inter() ;
    }
}
//调用InterDemo类中method方法
InterDemo id = new InterDemo() ;
id.method(new Inter(){
    public void inter(){
        //...
    }
}) ;

//如果一个方法的返回值是一个抽象类或者接口--都需要返回该抽象类或者接口子类对象!
给定下面代码,最终需要输出 "helloworld"
interface Inter{
    void show() ;
}
class Outer{

       //补全代码
    public static Inter method(){

        //接口匿名内部类
        return new Inter(){
            public void show(){
                System.out.println("helloworld") ;
            }
        };
    }

}

//class InterImpl implements Inter{}
public class OuterTest {
    public static void main(String[] args) {
        Outer.method().show() ;

        //Outer.method()----->被static修饰

       // ---->Outer.method().show()---->Outer.method()它是由返回值的
    }
}

4.Object类的getClass()是做什么用的？
Object类的getClass()----->
                获取一个类的字节码文件对象(获取字节码文件对象的方式1)
               任意Java类型的class属性
               Class.forName("包名.类名");   后期用到的多一些

5.接口与抽象类的区别
1)成员区别
       接口:
               成员变量:只能是常量默认修饰符 public static final
               成员方法:只能是抽象方法 public abstract
               构造方法:没有
       抽象类:
               成员变量:既可以是常量,也可变量
               成员方法:可以抽象,可以非抽象
               构造方法:有参/无参 ---分层初始化

2)关系区别
       类与接口:实现关系 implements
       类与类: extends:继承只支持单继承,不支持多继承,可以多层继承
       接口与接口:extends:继承可以支持单/多继承, 可以多层继承
3)设计理念区别
       抽象类--->需要有子类(具体类)继承它,进行实例化,体现的是一种"is a"的关系
       接口---->需要子实现类(implements) ,描述事物的一种额外的扩展功能,体现的 "like a"的关系

11.15晨写

1.描述Object类的toString()方法？
建议所有子类重写toString(),结果是描述成员信息表达式(更容易让人阅读)
String类的public String toString()-----> return this;

2.列举出String类中常用的获取功能（4个）
   获取指定索引的字符
char charAt(int index)
   拼接功能
String concat(String anotherStr)
   将字符串按照指定的分割符号拆分成字符串数组
String[] spilt(String speatorStr)
   截取
String substring(int beginIndex) //从指定位置开始默认截取到末尾
String substring(int beginIndex,int endIndex) //从指定位置开始截取到指定位置结束(endIndex-1处)
   查询指定字符串在大串第一次出现的索引值
int indexOf(String str)


    字符串按照字典顺序比较
int compareTo(String anotherStr)
    String s1 = "abc" ;
    String s2 = "cba" ;
   System.out.println(s1.compareTo(s2)) ;//'a'-'c'   -2

3.列举出String类的转换功能（5个）
   可以将任意Java类型转换成String (int/float/double/byte/short/long/char/boolean/Object)
public static String valueOf(任意Java类型){}
   将字符串转换成字符数组
char[] toCharArray(){}
   将字符串转换成字节数组
byte[] getBytes(){}
   将字节数转换成字符串---String的构造方法
String(byte[] bytes)
String(byte[] bytes,int index,int length)//从字节数组的某个位置开始,指定长度,转换成字符串
   将字符数组转换成字符串
String(char[] chs)/String(char[] chs,int index,int length)
   将字符串转换大写
String toUpperCase(){}
   将字符串转换成小写
String toLowerCase(){}

4.String类的特点？
String是一个常量,不可变的字符序列,一旦被赋值,其值不可更改!
推荐的创建方式:

  String s  = "abc" ;
        //String s = new String("abc") ;
        
        String str1 = new String("Hello");
        String str2 = new String("Hello");
        System.out.println(str1.equals(str2));
        System.out.println(str1 == str2);
        
        String s3 = "hello" ;
        String s4 = "world" ;
        String s5 = "helloworld" ;
        System.out.println(s5==(s3+s4)) ;
        System.out.println(s5.equals(s3+s4)) ;
        System.out.println(s3.equals(s4)) ;
        System.out.println(s3==s4) ;    
        
        System.out.println(s5 == ("hello"+"world"));

5.选择排序的思想以及核心代码体现
选择排序思想:使用0角标对应的元素依次和后面角标对应的元素进行比较,前面的值比后面大,将小的值往前放,第一次比较完毕,最小值出现在最小索引处;依次这样比较

for(int x = 0 ; x < arr.length-1; x++){
    for(int y = x+1 ; y < arr.length; y ++){
        if(arr[x] > arr[y]){
            int temp = arr[x] ;
            arr[x] = arr[y] ;
            arr[y] = temp ;
        }
    }
}

11.16晨写

1.String,StringBuffer,StringBuilder的区别
String:是一个常量,一旦被赋值,其值不能被更改 ,不可变的字符序列!
作为形式参数,形式参数的改变不影响实际参数(和基本类型作为形式参数传递的效果一致 ,特殊的引用类型)
StringBuffer:支持可变的字符串类,线程安全的类--->同步的--->执行效率低
StringBuffer的大部分功能--->synchronzied:同步锁(悲观锁)(多线程去讲)作为形式参数,形式参数的改变直接影响实际参数
StringBuilder:和StringBuffer具备相互兼容的API,线程不安全的类---不同步的---->执行效率高
单线程程序(只考虑效率)中,使用StringBuilder去替代StringBuffer
多线程环境下(要考虑安全),使用StringBuffer

2.String和StringBuffer的相互转换
String--->StringBuffer
   方式1:
       StringBuffer的有参构造
       String s = "hello" ;
       StringBuffer sb = new StringBuffer(s) ;
   方式2:
       StringBuffer的无参构造+append(String str)
       StringBuffer sb2 = new StringBuffer() ;
       sb2.append(s) ;

StringBuffer--->String
   方式1:
       StringBuffer的成员方法 public String toString()
       StringBuffer buffer = new StringBuffer("abc") ;
       String s = buffer.toString() ;

   方式2:
       String的构造方法 String(StringBuffer sb)
       StringBuffer buffer2 = new StringBuffer("abc") ;
       String s2 = new String(buffer2) ;

3.String日期文本和java.util.Date类型相互转换
String--->Date 解析(使用居多)
   String s = "2022-11-16" ;
   1)创建解析器
   SimpleDateFomart sdf = new SimpleDateFormat("yyyy-MM-dd") ;
   2)Date date = sdf.parse(s) ;

后面第三方---->jackson.jar --->java.util.Date日期对象--->@DateForamt(pattern="yyyy-MM-DD")
Date---->String 格式化
   1)创建当前日期对象
   Date date2 = new Date() ;
   2)创建解析器对象
   SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
   //3)格式化
   String dateStr =sdf2.format(sdf2) ;

4.将int类型数据赋值给Integer类型变量，它的内部缓区IntegerCache完成了什么事情？
   Integer i = 整数值;
   执行Integer类的valueOf(整数值)
   IntegerCahce: 静态成员内部类
if(整数值>= IntegerCahce.low && 整数值<=IntegerCache.high){
               //如果在-128-127之间,从Integer类型数组中取数据 Integer[]
   return IntegerCache.cache[整数- (-Integer.low)]
    }

如果不再范围内,直接开堆内存空间创建实例!
    return new Integer(整数值)

Integer i1 = 127 ;
Integer i2 = 127 ;
System.out.println(i1==i2) ; //true
Integer i3 = 128 ;
Integer i4 = 128 ;
System.out.println(i3==i4) ; //false

5.int和String之间的相互转换
int-->String
Integer类的静态方法
public static String toString(int i)

String:数字字符串--->int
Integer类的静态方法
public static int parseInt(String numberStr)

11.17晨写

1.Collection集合的遍历方式
1)Object[] toArray() //将集合转换成对象数组,里面的类型是Object类型
Collection<String> c = new ArrayList<>() ;
c.add("hello") ;
c.add("world") ;
c.add("java") ;
Object[] objects = c.toArray() ; // Object[] objects = {"hello","world","java"} ;
                                   //里面的每一个具体对象 Object obj = new String(xx) ;
for(int x = 0 l x < objects.length;x++){
   想去数据字符串内容,同时输出字符串长度 length()
   向下转型
    String s = (String)objects[x] ;
    System.out.println(s+"---"+s.length()) ;
}

2)迭代器 Collection 的 Iterator iterator()
Collection<String> c = new ArrayList<>() ;
c.add("hello") ;
c.add("world") ;
c.add("java") ;
   获取Collection的迭代器
Iterator<String> it = c.iterator() ;
while(it.hasNext()){
    String s = it.next() ;
    System.out.println(s+"---"+s.length()) ;
}

3)增强for循环
for(String s:c){
System.out.println(s+"----"+s.length()) ;
}
2.List集合的遍历方式
1)Collection集合的toArray()
2)Collection集合的迭代器Iterator iterator()
3)List集合的特有迭代器ListIterator listIterator()
4)List集合的E get(int index) 和int size()结合的普通for
5)增强for循环格式

3.List三个子实现类的特点？
ArrayList:
       底层数据结构是数组,查询快,增删慢
       线程不安全,不同步----执行效率高
       扩容机制是1.5倍
Vector
       底层数据结构是数组,查询快,增删慢
       线程安全,同步--->执行效率低(多线程环境下使用)
LinkedList
       底层数据结构是链表,查询慢,增删快
       线程不安全,不同步--->执行效率高
       应用场景:添加操作---每次将数据添加集合的前面/删除末尾元素

4.增强for的格式以及作用
增强for循环---作用:替代迭代器,简化代码书写
       for(存储的数据类型变量名: 集合对象或者数组对象 ){
            使用这个变量;
       }

5.获取类的字节码文件的方式
三种方式
   1)Object类的getClass()--->使用任意Java对象调用   Student s = new Student() ;
                                                  Class clazz1 = s.getClass()
                                                       //class 包名.类名
   2)任意Java类型的class属性       定义了学生Student
                                           Class clazz2 = Student.class;
   3)Class类提供静态方法forName("全限定名称") ;
   反射中用---->使用居多,参数是String字符串,可以在配置文件中进行配置!
    全限定名称:包名.类名

11.18晨写

1.TreeSet集合存储自定义类型如何实现自然排序和比较器排序
TreeSet基于TreeMap红黑树结构,存储第一个元素---根节点,后面的元素依次和根节点比较
小了,左子节点
大了,右子节点
相等,存以前的值

自然排序(默认使用的这种:大部分常用String/Integer/Character 都实现Comparable)
TreeSet<自定义类型>,如果要实现自然排序,使用TreeSet的无参构造方法 public TreeSet<E>()
自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...}

比较器排序
   TreeSet<E>(Comparator<T> com):有参构造方法
   方式1:自定义一个类实现Comparator接口---实现 public int compare(T t1,T t2){排序规则...}
   方式2:使用接口的匿名内部类
   TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){
        public int compare(自定义类型 t1,自定义类型 t2){排序规则...}

   }) ;

2.LinkedList集合的特有功能
addFirst():添加链表的开头
addLast():添加链表的末尾
public E removeFirst()删除并返回第一个元素
public E removeLast()删除并返回最后一个元素
public E getFirst():获取第一个元素
public E getLast():获取最后一个元素
如果需求大量 "写"的操作,采用LinkedList
大量"读"的操作,默认使用ArrayList,大量"读",考虑线程使用Vector

3.Vector集合遍历的特有方式有哪些
方式1:
   Enumrmation elements() ---->类似于 Iterator iterator()
       接口
           public boolean hasMoreElements() :是否有更多的元素----->public boolean hasNext()
           public E nextElement()   ------------->public E next()
方式2:
       普通for循环:size()和public E elementAt(int index)通过角标获取元素

4.描述String的compareTo(String str)字典顺序比较的逻辑
String字符串里面的compareTo(String str)逻辑
       "hello"
       "abc"
       "hell"
这个方法:将字符串---->字符数组---->获取两个字符串长度的最小值(临界点)
int k = 0 ;
while( k < 长度最小值){

    不断两个字符数组每一个字符
    如果第一个字符值不同,直接方法结束: 返回两个字符相减 (ASCII码表的值)
   k++
     如果循环结束之前,如果者两个字符串的都相同,返回字符串长度相减
}

面试题：

1)面试题:
                数组中没有length(),字符串有没有length(),集合中有没有length()?
                数组没有length(),length属性数组对象.length
                字符串有length(),
                 集合没有,获取集合中元素数 size()

2)面试题:

String s = new String("hello") ;和String s = "hello" ; 有什么区别?分别创建了几个对象?
区别
前者:在堆内存中开辟空间,然后字符串值常量---指向常量池, 两个对象
后者:推荐的方式,直接常量赋值,直接在常量池中找,有就返回地址,没有,开辟常量空间!

3)面试题
String s1 = "hello";
String s2 = "hel" ;
按照字典顺序比较,它的结果是多少? 考察的就是compareTo的源码
public int compareTo(String anotherString):两个字符串按照字典顺序比较! 两个字符串进行字典顺序比较,先算出长度,取出最小值,然后比较每一个字符,如果这俩个字符串的第一个字符都不相同
使用前面的字符和后面的的字符进行相减(ASII码表的值相减)
如果长度的最小值,在循环遍历两个字符串的每一个字符之前,都相同,直接是两个字符串长度相减!

4)面试题List集合三个子实现类特点
三个子实现类的特点
           ArrayList:
                  底层数据结构是数组---> 查询快,增删慢
                   从线程角度--->线程不安全的---->不同步--->执行效率高
                   不明去使用什么集合(单线程),默认ArrayList
           LinkedList
                   底层数据结构是链表--->查询慢,增删快
                   从线程角度--->线程不安全---->不同步---->执行效率高
                    当如果要去删除最后一个元素/将每一个元素添加集合开头需求
                           使用LinkedList
          Vector
                  底层数据结构也是数组---->查询快,增删慢
                 从线程角度--->线程安全的类---->同步--->执行效率低(多线程环境用)

5)面试题
Map和Collection的区别 ?
Collection<E>:单例集合,只能存储一种引用类型数据遍历方式和Map不同;
Collection集合的应用范围大:
                       ArrayList
                       Vector
                       LinkedList
它里面的部分集合和Map有关联(HashSet--->依赖HashMap   / TreeSet---->依赖于TreeMap)
Map<K,V>,双列集合---->可以存储键值对("夫妻对")
遍历方式:通用方式获取所有的键,通过键找值!
应用范围:
             HashMap---->存储和获取 (默认使用)
             TreeMap---->存储---获取(按照排序规则排序)
             Map---->称为 "实体"
                    Map<Integer,Product>

重点：

Jdk5里面其他新特性:
1)静态导入---->导入到方法的级别
        import static 包名.类名.方法名;
        前提使用静态导入,这个类的方法必须为静态
        在使用静态导入的时候,导入jdk提供的一些工具类里面静态方法的时候,我们定义的方法不能和它方法名冲突
        如果冲突了,静态导入是不识别,这个时候必须导入全限定名称 :包名.类名.方法名(xxx)
        2)可变参数,当一个方法形式参数不知道多少个,这个时候可以使用可变参数(类似一个数组)
public 返回值类型方法名(数据类型... 参数名)

import  static java.lang.Math.abs;
import static java.lang.Math.max; //最大值
import static java.lang.Math.min; //最小值
import static java.lang.Math.pow;  //pow(a,b)  a的b次幂
public class JDK5StaticDemo {
    public static void main(String[] args) {

        //java.lang.Math:针对数学运算的类
        //public static double/int abs(double/int a,double/int b):求绝对值
        //...都是静态成员方法
        System.out.println(Math.abs(-10));
        System.out.println(Math.abs(100));

        System.out.println(java.lang.Math.abs(-100));//使用到了静态导入,方法名和自定义的方法名冲突了
        System.out.println(max(10,15));
        System.out.println(min(5,3));
        System.out.println(pow(2,3));
        System.out.println("---------------------------------");
        int sum = add(10, 20, 30, 40, 50);
        System.out.println(sum) ;
    }

    //自定义的abs方法
    public static void abs(int a){
        System.out.println(a);
    }

    //求多个数据和
    public  static int add(int...a){//类似一个数组
        int sum = 0 ;
        //遍历
        for(int x = 0 ; x < a.length  ;x++){
            sum += a[x] ;
        }
        return sum ;

    }
}