Java 2106 第四周总结

本周总结

一、内部类

1、局部内部类

书写位置：在外部类的成员方法中定义的类
局部内部类可以访问外部类的成员变量包括私有！
在外部类的局部位置，访问内部类的成员方法，创建当前局部内部类对象来访问

面试题
局部内部类访问局部变量的时候,此时局部变量应该注意什么?(JDK7/JDK8),为什么要加入final关键字呢?

class Outer2{
    public void method(){
        int num = 20 ; //局部变量

                class Inner2{
                    public void show(){
                        System.out.println(num);
                    }
                }
                    //创建Inner2类对象
                        Inner2 inner2 = new Inner2() ;
                        inner2.show();
                    }
                }
//测试类
public class OuterDemo2 {
    public static void main(String[] args) {
        //创建Outer2对象
        Outer2 outer2 = new Outer2() ;
        outer2.method();
    }
}

原因：
局部变量的生命周期是随着方法调用而存在，随着方法调用结束而消失
而当前内部类对象调用medthod方法的时候，此时num进入栈内存，在局部位置创建了局部内部类对象
而局部内部类对象调用它的成员方法访问该变量，方法medthod方法结束后，内部类对象不会立即消失，它里面的成员方法在访问局部变量，局部变量必须变成常量，常驻内存，否则如果当前变量消失了，局部内部类的成员依然在访问，就会出现冲突！所以jdk7之前必须加入final修饰，jdk8通过jvm已经做了优化了，无需手动加入final修饰符

2、匿名内部类

概念 ： 没有名字的内部类
一般在局部位置使用
格式： 匿名内部类是内部类的一种简化格式
new 类名(可以是抽象类，也可以是具体类)或者接口(){
重写功能
};
本质：
继承了该类或者是实现了该接口的子类对象
匿名内部类在开发中的使用
方法的形式参数如果是一个抽象类，那么实际参数可以需要接口的子类对象
1）将子类定义出来，继承自抽象类
2）直接使用抽象类的匿名内部类

//形式参数是一个抽象类
abstract class Person{
    public abstract void work() ;
}
interface Love{ //接口
    void love() ;
}
class StudentDemo{
   // public void method(Person person){	
      public void method(Love l){
        //person.work() ;
          l.love() ;
    }
}
class Test{
    public static void main(String[] args){
        //创建StudentDemo类对象
        StudentDemo sd  = new StudentDemo() ;
        /*
        sd.method(new Person(){  //抽象类的匿名内部类
            @Override
            public  void work(){
                //....
            }
        }) ;
        */
        sd.method(new Love(){
            public void love(){
                //...
            }  
        }) ;
    }
}

方法的返回值是一个抽象类： 需要返回的是当前抽象类的子类对象
方法的返回值是接口类型,需要返回的当前接口的子实现类对象

//返回值问题:也可以使用匿名内部类
//需要在控制台输出"helloworld"
interface Inter{
    void show() ;
}
class Outer{
    
    //补全代码
    public static Inter method(){
        return new Inter(){
           	public void show(){
                System.out.println("helloworld") ;
            } 
        } ;
    }
}
class Test{
    public static void main(String[] args){
        Outer.method().show() ;
        //   Outer.method().show() ;Outer.method()-->具有返回值的方法
    }
}

二、Object

java.lang.Object:是类结构层次的根类，所有的类都默认继承自Object子类（派生类）

1、Object功能类的getClass()方法

public final Class getClass():表示正在运行的类（字节码文件对象）
Class ——>反射的时候使用
Class类
功能：
public String getName()：获取当前类的全限定名称（包名.类名）

Object类中的getClass()/finnalize/hashCode()以及以后常用类
功能中，如果native关键字：本地方法，非Java语言底层实现
public int hashCode():获取对象的一个哈希码值（本质不是地址值，可以理解为地址值）
一般情况：不同的对象获取的哈希码值是不同的。

获取类的字节码文件对象的方式
1）通过Object类的getClass()—>Class：正在运行的Java类：class 包名.类名
2）任意java类型的class属性—获取当前类的字节码文件对象
3）Class里面的forName("类的全限定名称(包名.类名)“)；

2、Object的pubic String toString()

返回对象的字符串表示形式，结果应该是一个简明扼要的表达，容易让人阅读
建议所有子类覆盖此方法
大部分的常用类或者后面的集合都会重写Object类的toString()

3、 Object类的equals方法

public boolean equals(Object obj）
判断当前obj对象是否和当前对象相等

equals和==的区别

==：连接的基本数据类型：比较的是数据值是否相同
==：连接的是引用类型：比较的是地址值是否相同
equals方法：如果使用Object默认的：底层用==，默认比较的还是两个对象的地址值是否相同

Studnet s1=new Student(“张三”)；
Studnet s2=new Student(“张三”)；
s1和s2虽然地址值不同，它们的成员内容相同，认为他是同一个人,但是如何让s1.equals(s2)为true:针对equals来说比较的是成员信息内容是否相同;
重写Object的equals方法同时还需要重写hashCode
内容相同,还需要比较哈希码值相同
重写之后,就比较的是成员信息的内容是否相同!

4、Object的clone克隆方法

protected Object clone() throws CloneNotSupportedException:创建对象并返回该对象
此方法会抛出一个异常，throws ：表示的是可能出现异常，针对调用者必须处理

要使用clone方法，当前某个对象所在的类必须实现”标记接口“Cloneable(没有字段(成员变量)，也没有成员方法)
实现这个类，那就可以使用Object的clone()方法

三、Scanner

Scanner类：文本扫描器 Java.util.Scanner;

1、构造方法

public Scanner(InputStream source) :创建一个文本扫描器
形式参数是一个抽象类—>
它通过System类里面的public static final InputStream in
System类中
public final static InputStream in = null;
本地方法(非Java语言实现)—> private static native void setIn0(InputStream in);
底层方法一定会创建系统资源---->读取用户输入的 字符(整数,字符串…)

2、Scanner类提供判断功能

防止输入的类型和结果类型不匹配
public boolean hasNextXXX():判断下一个录入的是否为指定的XXX类型
XXX nextXXX() 获取功能

四、常用类

1、String

java.lang.String:代表的字符串
字符串是一个常量，一但被赋值，其值（地址值）不能被更改
使用方式
String 变量名 =“xxxx”;//xxxx代表的当前String的实例

构造方法
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):构造一个字符串,参数为字符串常量

String类的常用功能

1)转换功能

byte[] getBytes() :将字符串转换成字节数组(编码)
如果方法为空参，使用平台默认的编码集进行编码
byte[] getBytes(String charset):使用指定的字符集进行编码
解码的过程：将看不懂得字节数转换成 String
String(byte[] bytes); 使用默认的字符集进行编码
String(byte[] bytes,指定字符集)

字符集

gbk：一个中文两个字节（中国中文编码集）
gb2312：gbk升级版（含义有一个中文字符：中国的中文编码集）
iso-8859-1：拉丁文码表
utf-8：任何的浏览器都支持 utf-8格式
unicode：国际编码集
JS:日本电脑字符集
arrays
静态功能：
public static String toString(int/byte/float/double…[]a):将任意类型的数组—>String
public char[] toCharArray():将字符串转成字符数组
public String toString():返回自己本身–“当前字符串的内容”
public String toUpperCase():将字符串转换成大写
public String toLowerCase():将字符串转换成小写

2）判断功能

public boolean equals(Object anObject):比较两个字符的内容是否相同 (区分大小写)
public boolean equalsIgnoreCase(String anotherString):比较两个字符串是否相同(不区分大小写)
public boolean startsWith(String prefix):判断字符串是否以指定的内容开头
public boolean endsWith(String suffix):判断字符串是否以指定的内容结尾
boolean isEmpty() 判断字符串是否为空 :若为空,则返回true;否则返回false

		 String s = "" ;// 空字符串 ,存在String对象 ""
		 String s = null ; 空值 (空对象) null:引用类型的默认值

3)获取功能：

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类型

4、其他功能

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

2、 StringBuffer

StringBuffer:字符串缓冲区 ---->类似于String,但是不一样 (可变的字符序列)，里面存储的字符序列

1)构造方法

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

2） 添加功能:

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

3）删除功能

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

4）特有功能

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

5）截取功能

public String substring(int start):从指定位置开始,默认截取到末尾,返回值是新的字符串
public String substring(int start,int end):从指定位置开始到指定end-1结束进行截取,返回的新的字符串

6）替换功能

public StringBuffer replace(int start, 起始索引
int end, 结束索引(end-1)
String str) 替换的内容

面试题:

 **StringBuffer和数组的区别?**

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

面试题:

StringBuffer,StringBuilder和String的区别?
String:字符串是一个常量,一旦被赋值,其值不能更改/作为形式参数属于特殊的引用类型,形式参数的改变不会实际参数
StringBuffer:可变的字符序列,线程安全的类----同步的----->执行效率低(线程角度)
StringBuilder:可变的字符序列.和StringBuffer具有相互兼容的api,单线程程序中(只考虑执行效率,不考虑安全问题), 会使用StringBuilder替代StringBuffer

3、Integer

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

1)构造方法

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

2）Integer类成员方法

int类型和String类型的相互转换
int – String
String – int
public int intValue()
public static int parseInt(String s)
public static String toString(int i)
public static Integer valueOf(int i)
public static Integer valueOf(String s)
常用的基本进制转换
public static String toBinaryString(int i)
public static String toOctalString(int i)
public static String toHexString(int i)

3）JDK5的新特性

JDK1.5以后，简化了定义方式。
Integer x = new Integer(4);可以直接写成
Integer x = 4;//自动装箱。
x = x + 5;//自动拆箱。通过intValue方法。
需要注意：
在使用时，Integer x = null;上面的代码就会出现NullPointerException。

4、Charcater

Charcater :char类型的包装类类型

1）构造方法：

public Character(char value)

2）主要功能：

public static boolean isUpperCase(char ch):判断当前字符是否大写字母字符
public static boolean isLowerCAse(char ch):是否为小写字母字符
public static boolean isDigit(char ch):是否为数字字符

5、Calender

日历类:java.util.Calendar
Calendar:提供一些诸如 获取年,月,月中的日期 等等字段值，是一个抽象类,不能实例化
public static Calendar getInstance()
成员方法:
public int get(int field):根据给定日历字段----获取日历字段的值(系统的日历)
public abstract void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量
参数1:日历字段 参数2:偏移量

6、Date，DateForamt

java.util.Date:表示特定瞬间,精确到毫秒!
构造方法:
public Date():当前系统时间格式
public Date(long date):参数为 时间毫秒值---->Date对象 (1970年1月1日…)
DateForamt:抽象类----提供具体的日期/格式化的子类:SimpleDateFormat
format(Date对象)—>String
SimpleDateFormat:构造函数
public SimpleDateFormat():使用默认模式
public SimpleDateFormat(String pattern):使用指定的模式进行解析或者格式 (推荐)

7、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():[0.0,1.0):随机数
public static long round(double a):四舍五入
public static double sqrt(double a):开平方根
Math类中的功能都是静态的,里面构造方法私有了
一般情况:工具类中构造方法都是会私有化(自定义的工具类),提供对外静态的公共访问方法

8、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)

9、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:舍入模式 :四舍五入

五、集合

集合和数组有什么区别?

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

1、 Collection

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

1）基本功能

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

2）高级功能

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

3)Collection的迭代器

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

2、jdk5后的新特性：泛型<E/T>

1)格式

<引用数据类型>
创建集合对象的时候,明确了集合中存储的数据类型<>
集合类型<引用数据类型> 集合对象名 = new 子实现类<引用数据类型>() ;

2)泛型的好处

1)将运行时期的异常提前到了编译时期
2）避免了强制类型转换
3）提高了程序安全性

3、List接口

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 listIterator():列表迭代器：List集合专有遍历方式

 ListIterator接口:
 void add(E e)有添加
  remove():有删除

java.util.ConcurrentModificationException:并发修改异常

集合在使用迭代器会经常出现的问题:并发修改异常,
当集合的元素正在被迭代器进行遍历,那么集合对象是不能够对元素进行增加或者删除 (一个线程正在遍历,一个线程在修改元素)
解决方案:

•  1)要么就是迭代器去遍历集合的元素,迭代器去添加元素  :列表迭代器才具备添加的动作
  

•  2)要么集合遍历,集合添加
  

4） Vector集合

特有功能
添加
public void addElement(Object obj):在vector对象的末尾添加元素 ------> 一直使用的add(Object e)
删除
public boolean removeElement(Object obj):删除元素
获取功能
public Object elementAt(int index):获取指定位置的元素---->类似于 public Object get(int index)
public Enumeration elements() :Vector集合的专有遍历方式---->类似于 Iterator literator()
boolean hasMoreElements():判断是否有更多的元素可以迭代
Object nextElement() 获取元素

5）List集合三个子实现类的特点

ArrayList
底层数据结构是数组,查询快,增删慢
通过arr[索引值]:查询到某个元素

    存储null元素---->

    线程角度:   线程不安全的类,实现不同步的  ----->执行效率高
    特点:扩容机制:1.5倍的方式扩容
    Integer[] arr = {11,22,33,44,55} ;
    添加和删除元素:需要判断
            在33这个元素后面新的元素,需要新建数组,长度是以前数组长度+1
            判断加入的元素是否33元素
            33以前,按照以前的元素在新的数组进行存储
            33,继续存储
            33以后的,加入88元素(给33以后的元素后面插入新的元素)

    public ArrayList():无参构造方法:默认容量是10

Vector集合:
底层数据结构是数组,查询快,增删慢
线程角度:线程安全的类----同步的方法---->执行效率低
单线程程序中.考虑集合默认都会使用 ArrayList,多线程环境集合---->Vector集合
LinkedList
底层数据结构是链表,查询慢,增删快
线程角度:线程不安全的类---->不同步---->执行效率高
特有功能:
addFirst()
removeFirst()
getFirst()
xxxLast()
应用场景:模拟栈结构特点:
先进后出
如果没有明确要求使用什么(List)集合的时候 ,默认都是用ArrayList

6）增强for循环

格式

for(存储的引用数据类型 变量名: 集合/数组对象){ //集合使用居多,数组一般都是使用普通for
使用变量名即可
}

注意事项

当前集合对象不能为空 null :foreach语句:增强for它本身就是获取迭代器了,就会出现空指针异常

运用举例

public class ForeachDemo {
    public static void main(String[] args) {
        //数组
        int[] arr = {11,22,33,44,55} ;
        for(int x  = 0 ; x < arr.length ; x ++){
            System.out.println(arr[x]);
        }
        System.out.println("--------------------------------");
        /*
        for(存储的引用数据类型 变量名: 集合/数组对象){
        *            使用变量名即可
                    *      }
         */
        //对于数组来说:使用普通for
       /* for(int a:arr){
            System.out.println(a);
        }*/
       //创建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角标对应的元素进行和0角标比较
如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较
依次这样比较…

核心代码

public class InsertSortTest {
    public static void main(String[] args) {
        //定义一个Integer数组: Integer实现的自然排序:元素能够按照升序默认排序
        Integer[] arr = {34,8,64,51,32,21} ;

        System.out.println("排序前:");
        printArr(arr);
        //定义一个功能
        insertSort(arr) ;
        System.out.println("排序后:");
        printArr(arr);
    }
    //插入排序
    private static void insertSort(Integer[] arr) {
        //定义一个变量j
            int j ; //j记录当前角标的变化
            //定义变量 : p:表示一个比较次数 p=1,2,3,4,5 (每一移动的元素的位置)
            for(int p = 1 ; p < arr.length ; p ++ ){ //比较次数     p=2
                //定义临时变量temp
                Integer 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=2
                arr[j] = temp ;         // 没有移动
        }
    }
    public static void printArr(Integer[] arr){
        System.out.print("[");
        for(int x = 0 ; x < arr.length ; x ++){
            if(x == arr.length -1){
                System.out.println(arr[x] +"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
}