学习java的第四周

一、内部类

1.局部内部类（在外部类的成员方法中定义的类）

1）局部内部类可以访问外部类的成员变量包括私有
2）在外部类的局部位置,访问内部类的成员方法,创建当前局部内部类对象来访问
注：外部类和内部类没有继承关系

2.匿名内部类（没有名字的内部类）

1）格式：new 类名(可以是抽象类,也可以具体类)或者是接口名(){
重写功能
} ;
2）本质：继承了该类或者是实现了该接口的子类对象

3.匿名内部类在开发中的使用

1）方法的形式参数如果是一个抽象类,实际参数需要传递的是抽象类的子类对象
2）方法的形式参数如果是一个接口,实际参数需要传递的是接口的子实现类对象
3）方法的返回值是一个抽象类，需要返回的是当前抽象类的子类对象
4）方法的返回值是接口类型,需要返回的当前接口的子实现类对象

二、Object类

1.java.lang.Object:是类结构层次的根类,所有的类都默认继承自Object类

2.获取一个类的字节码文件对象有三种方式：

1）Object类的getClass()方法
2）任意Java类型的class属性
3）Class.forName(“包名.类名(类的全限定名称)”)

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

1）public String toString():对象的字符串表现形式（需要子类重写这个方法,否则如果直接输出对象名称,打印出来的是一个"地址值"。）
2）==和equals
==:如果连接的基本数据类型:比较数据值是否相同
==:如果连接的引用数据类型:比较的是对象的地址值是否相同
equals:如果不重写Object的equals,它默认比较的是两个对象的地址值是否相同（子类重写equals方法的同时,还需要重写hashCode() ，(对象不同,哈希码值也是不同的)）
注：String类型的底层已经对Object的equals重写了,所以String的equals就比较的是字符串内容是否相同
3）克隆方法（要进行克隆必须实现标记接口Cloneable(没有字段(成员变量),也没有成员方法)）
protected Object clone() throws CloneNotSupportedException:创建对象并返回该对象的副本
这个方法会抛出一个异常,throws:表示的是可能出现异常

三.Scanner类:文本扫描器

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

四.String类

1）字符串是一个常量,一旦被赋值了,其值(地址值)不能被更改）（java.lang.String:代表的字符串）（格式：String 变量名 = “xxxx” ;）
2）获取以及常用功能：

int length() {}//获取字符串长度的功能
charAt(int index) {}  //返回指定索引处的字符
String[] split(String regex){} //String类的拆分功能,通过特定字符串将字符串---转换成String数组
String concat(String anotherStr){}//字符串类的拼接功能
int indexOf(String str/char ch){} //查询某个字符或者子字符串第一次出现的索引值
String subString(int beginIndex){}//从指定位置处默认截取到末尾
String subString(int beginIndex,int endIndex){}//从指定位置截取到指定位置结束(endIndex-1)
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（重点）

3）转换功能：

byte[] getBytes(){}//将字符串转换成字节数组
String(byte[] bytes){}//解码:String类构造方法
char[] toCharArray(){}//将字符串转换成字符数组
String(char[] chs){}//将字符数组转换成String
StringBuffer(String str) //String转换为StringBuffer
String toUpperCase():将字符串转换成大写
String toLowerCase():将字符串转换成小写
public static String valueOf(boolean/int/long/float/double/char...Object b)   （万能方法,将任意类型转换String类型）

4）判断功能：

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

5）String类的遍历
第一种：用String类的length():获取字符串长度 + charAt(int index)
第二种：String转换为字符数组toCharArray()

五、StringBuffer（字符缓冲区）

1.StringBuffer和数组的区别

1）共同点:都是容器,都可以存储任意类型的元素 , 可以存储基本类型,也可以存储引用类型
2）数组---->同一种类型的元素 长度是固定的
3）StringBuffer---->存储不同类型的元素 append(int/char/double/Object/foat…) 长度是可变的

2.StringBuffer和StringBuilder的区别

1）共同点：两个都是字符串缓冲区,支持可变的字符序列
2）不同点：
StringBuffer:线程安全的类---->同步的----->执行效率低
StringBuilder:线程不安全的类---->不同步----->执行效率高

单线程程序中,只考虑执行效率不考虑安全,所以StringBuilder类用作StringBuffer的简易替换
多线程环境中,要考虑安全问题只能使用StringBuffer

3)StringBuffer常用功能

StringBuffer  append(任何类型) :将内容追加到字符串缓冲区中 (在字符串缓冲区的最后一个字符序列的末尾追加)
public StringBuffer insert(int offset,String str):插入:在指定位置处插入指定的内容
public StringBuffer deleteCharAt(int index):删除指定索引处的缓冲区的字符序列,返回字符串缓冲区本身
public StringBuffer delete(int start,int end):删除从指定位置到指定位置结束的字符序列(包含end-1处的字符)
StringBuffer的反转功能:reverse()
StringBuffer的截取功能:subString(int bengin,int end)
StringBuffer的截取功能:subString(int bengin）

3.StringBuffer和String的转换

1）
//String--->StringBuffer
String s = "hello" ;
//方式1：使用StringBuffer的有参构造方法
StringBuffer sb = new StringBuffer(s)
System.out.println(sb); 

//方式2：StringBuffer的追加功能
StringBuffer sb1 = new StringBuffer() ;
sb1.append(s) ;
System.out.println(sb1);


2）
//StringBuffer--->String
///方式1:String类的构造方法
StringBuffer buffe = new StringBuffer("world") ;
String str = new String(buffer) ;
System.out.println(str);

/方式2:StringBuffer的public String toString()方法
String str1= buffer.toString();
System.out.println(str1);

六、Integer（缓存区中范围:-128~127）

1）int类型的包装类类型(引用类型),包含了int类型的原始数据值
2）进制的转换----可以使用Integer静态功能 十进制---->二进制 “以字符串形式体现”
public static String toBinaryString(int i):将整数---->二进制 的字符串
public static String toOctalString(int i):将整数---->八进制的字符串
public static String toHexString(int i):将整数---->十六进制数据
3）Integer的构造方法:
Integer(int value):可以将int类型保证为Integer类型
Integer(String s) throws NumberForamtException: 抛出一个数字格式化异常
注:当前字符串如果不是能够解析的整数的,就会出现数字格式化异常,s必须为数字字符串
4）JDK5之后的新特性:自动拆装箱,可变参数,静态导入,增强for循环,<泛型>,枚举类
自动拆装箱:
基本类型—> 对应的包装类类型 (装箱) （int---->Integer）
对应的包装类型---->基本类型 (拆箱) （Integer—>int）

1.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() ;
      System.out.println(num);

七、Character（char类型的包装类类型）

1）主要功能

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):将字符转换成大写

八、Calendar（日历类:java.util.Calendar）

1）提供一些获取年,月,月中的日期等字段值
2）（抽象类,不能实例化）
静态功能,返回值是它自己本身
public static Calendar getInstance()
3）成员方法:
public int get(int field):根据给定日历字段----获取日历字段的值(系统的日历)
public abstract void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量

九、java.util.Date:表示特定瞬间,精确到毫秒（允许格式化和解析日期字符串）

1.构造方法

public Date():当前系统时间格式
public Date(long date):参数为 时间毫秒值

2.Date和String类型的转换

//java.util.Date---->String： 格式化操作
//1)创建Date对象
Date date = new Date() ;
//2)创建SimpleDateFormat对象（DateForamt:抽象类----提供具体的日期/格式化的子类: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

3.DateUtils（针对java.util.Date日期对象和String:日期文本字符串进行相互转换的工具类）public static String date2String(Date date,String pattern){ //Date---->String1

1）public class DateUtils {
    //构造方法私有化
    private DateUtils(){}
 //Date---->String
public static String dateString(Date date,String pattern){
//分步走
        //创建SimpleDateFormat对象
     SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
        String result = sdf.format(date);
        return  result ;
//一步走
        return new SimpleDateFormat(pattern).format(date) ;
    }
}
//测试类
    Date date = new Date() ;
        String str = DateUtils.dateString(date, "yyyy-MM-dd HH:mm:ss");
        System.out.println(str);
2）public class DateUtils {
    //构造方法私有化
    private DateUtils(){}
    //String--->Date: 解析过程: parse(String source) throws ParseException
public static Date stringDate(String source,String pattern) throws ParseException {
//分步走
//创建SimpleDateFormat对象
     SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
        String result = sdf.parse(source);
        return  result ;
//一步走
        return new SimpleDateFormat(pattern).parse(source) ;
    }
}
//测试类
String source = "2021-7-31" ;
        Date date = DateUtils.stringDate(source, "yyyy-MM-dd");
        System.out.println(date);

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

十一、Math（类中的功能都是静态的,里面构造方法私有了）

1.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):开平方根

2.Java提供的类: java.math.BigDecimal

1）构造方法
public BigDecimal(String value):数字字符串
2）成员方法:

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

十二、Collection集合

1.基本功能:

添加
boolean add(Object e):添加元素
boolean addAll(Collection c):添加一个集合中的所有元素
删除:
void clear() 暴力删除(将集合的素有元素全部干掉)
boolean remove(Object o):从集合中删除指定的元素
boolean removeAll(Collection c):删除集合中的所有元素,(删除一个就算删除)
获取集合的元素数 :int size()
boolean isEmpty():判断集合是否为空,为空元素,则返回true
boolean contains(Object o):判断集合中是否包含指定元素,包含则返回true
boolean containsAll(Collection c):包含一个集合中的所有元素
boolean retainAll(Collection c)：交集（A集合和B集合求交集,交集的元素存储在A集合中,然后返回值的意思: 看A集合的元素是否有变化(之前的元素和现在交集的元素进行对比)，如果有变化,返回true;没有变化,则返回false）

2.List集合（最具体的子实现类ArrayList,LinkedList,Vector）和Set集合特点

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

3.Iterator（Collection的迭代器:集合的专有遍历方式）

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

4.集合遍历

//两种:
//方式1:将Collection转换成Object[]  toArray(){}
Collection<String> c = new ArrayList<String>() ;
c.add("hello") ;
c.add("javaee") ;
c.add("javaweb") ;

//方式1：直接转成对象数组
Object[] objs = c.toArray() ;
//遍历数组
for(int x = 0 ; x < objs.length; x ++){
    System.out.println(objs[x]) ;
}

//方式2:获取Collection的Iterator迭代器(集合高效的遍历方式)

Collection<String> c2 = new ArrayList<String>() ;
c2.add("hello") ;
c2.add("javaee") ;
c2.add("javaweb") ;

Iterator<String> it = c2.iterator() ;
while(it.hasNext()){
    String  str = it.next();
    System.out.println(str);
}

5.集合和数组的区别

1)长度区别
数组:长度固定
集合:长度可变
2)存储数据类型的区别
数组:
可以存储基本数据类型,也可以存储引用数据类型
集合:前提条件:集合中加入泛型<> 模拟数组的特点
只能存储引用类型 Collection :泛型<引用类型>
3)存储元素的区别:
数组:存储的元素必须为同一种数据类型
集合:如果没有加入泛型:就存储任意类型的元素(必须是引用类型)

6. jdk5以后新特性:泛型<E/T>

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

十三、List 集合（继承Collection， 具备Collection相关的功能：

Object [] toArray() terator iterator()））

1.特点：有序(存储元素和取出元素一致) 允许元素重复

2.特有功能：

void add(int index,Object element):在指定的索引处插 入元素
Object get(int index):获取指定位置处的元素
Object remove(int index):删除指定位置处的元素
Object set(int index,E element):修改指定位置处的元素(替换)
补充：ListIterator listIterator():列表迭代器
ListIterator listIterator():列表迭代器
ListIterator接口:
void add(E e)有添加
remove():有删除

3.List集合的遍历方式

方式一：Object[] toArray()
方拾二：Collection的迭代器 Iterator iterator()
方式三：Object get(int index):获取指定位置处的元素 + int size()
方式四：ListIterator listIterator():列表迭代器 :List集合专有遍历方式
方式五：增强for循环

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

解决方案:
方式1)迭代器去遍历集合的元素,迭代器去添加元素 :列表迭代器才具备添加的动作
方式2)集合遍历,集合添加

5.List集合去重

方式1:新建空集合思想
存储字符串类型并保证集合的元素唯一
方式2:利用选择排序的思想去完成
List集合—集合列表角标从0开始
遍历当前集合
然后使用0角标对应的元素依次和后面对应的元素进行比较,如果后面的元素和前面的相同了,那么将后面的元素删除掉
角标–
注：存储自定义对象去重需要集合存储的类型所在的类必须重写equals方法否则默认使用Object的equals方法比较的地址值是否相同。

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

1）ArrayList：
底层数据结构是数组,查询快,增删慢
通过arr[索引值]:查询到某个元素
线程角度: 线程不安全的类,实现不同步的 ----->执行效率高
注：public ArrayList():无参构造方法:默认容量是10
2）Vector:
底层数据结构是数组,查询快,增删慢
线程角度:线程安全的类----同步的方法---->执行效率低
单线程程序中.考虑集合默认都会使用 ArrayList,多线程环境集合---->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() 获取元素
3）LinkedList
底层数据结构是链表,查询慢,增删快
线程角度:线程不安全的类---->不同步---->执行效率高
特有功能:
addFirst()
removeFirst()
getFirst()

                        xxxLast()
    应用场景:模拟栈结构特点:
               先进后出

注：没有明确要求使用什么(List)集合的时候 ,默认使用ArrayList

十四、JDK5以后 提供了增强for循环,替代集合中迭代器去遍历集合使用的(优先在集合中使用)

1）格式:
for(存储的引用数据类型 变量名: 集合/数组对象){ //集合使用居多,数组一般都是使用普通for
使用变量名即可
}
注:当前集合对象不能为空 null :foreach语句:增强for它本身就是获取迭代器了,否则出现空指针异常

十五、插入排序

思想:使用1角标对应的元素进行和0角标比较，如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较，依次这样比较。

//定义一个变量j
            int j ; //j记录当前角标的变化
            //定义变量 : p:表示一个比较次数 p=1,2,3,4,5... (每一移动的元素的位置)
            for(int p = 1 ; p < arr.length ; p ++ ){ //比较次数
                //定义临时变量temp
                Integer temp = arr[p] ; 
                //开始比较
                for(j = p ; j>0 && temp.compareTo(arr[j-1])<0; j-- ){  //
                    //数据移动
                    arr[j] = arr[j-1] ;
                }
                //确定temp的位置
                arr[j] = temp ;         // 没有移动
        }