常见API对象

常见API对象

1、包

1、概念
     包就是文件夹，用于区分相同的类名

2、声明格式
     package 包名1.包名2….;
     package:是个关键字
3、带包的类的编译和运行

     javac –d . 文件名.java

4、导包
     import 包名1.包名2…;    

     如果我在一个类中需要用到不同包下的两个类，并且这两类名同名

     方式1：通过关键字import导入一个包，另一个用类全名

     方式2：两个都用类全名

5、package ,import ,class 的出现顺序
     package-->imoprt-->class
     注意：

          package 最后面有;
          class 类名后面是大括号
          import,package是关键字，不是类名

2、访问权限修饰符

1、四种权限修饰符
     1、private 

               被private修饰的成员只能在本类中使用
     2、默认     

               被默认修饰的成员不仅能在本类中使用，还能在同一个包下的其他类中使用
     3、protected

               被protected修饰的类不仅能在本类中使用，还能在同一个包下的其他类中使用，主要为了让子类继承时使用.(一句话：就是为了让子类使用的)
     4、public

               公共访问方式，表示最高的访问权限，被修饰的方法还可以在不同包下访问

2、访问修饰符汇总

修饰符 \ 元素

类本身

成员变量

成员方法

构造方法

private

内部类使用

Y

Y

Y

默认

Y

Y

Y

Y

protected

内部类使用

Y

Y

Y

public

Y

Y

Y

Y

static

内部类使用

Y

Y

 

abstract

Y

 

Y

 

final

Y

Y

Y

 

    
推荐
     以后所有的类都用public修饰，并且在一个Java文件中只定义一个类
     所有的成员变量用private修饰
     所有的方法用public修饰(工具类和单例除外)
     接口中所有的方法和成员变量把修饰写全
     所有的构造方法用public修饰

3、内部类

1、什么时候用

     B类如果要直接使用A类中的 所有 成员的时候就把B类定义到A类里面

2、内部类和继承的区别

     内部类可以直接访问外部类的私有成员

     但是子类要想访问外部类的私有成员的话只能通过get/set方法间接访问    

2、访问特点(注意事项)
          1、内部类可以直接访问外部类 所有 成员
          2、外部类想要访问内部类成员，必须内部类创建对象
3、内部类分类
          1、成员内部类
               A、其他类如何使用该内部类？
                    外部类名.内部类名 变量名 = new 外部类构造方法.new 内部类构造方法;
                     private:一般就是为了安全
                     static:一般就是为了方便调用
               B、注意问题
                     如果一个内部类含有静态方法，那么该内部类必须被静态修饰
                     如果一个类被定义为静态时，该类中可以没有静态方法
          2、局部内部类
               定义在方法中的类
               结论
               局部内部类访问局部变量，该局部变量必须被final修饰,因为被final 修饰就变成常量，在方法区中，他的生命周期延长了

4、匿名内部类
     概念：没有名字的局部内部类
     前提：必须存在一个类，抽象类或者接口
     格式：     

                    new 类名或接口名(){
                          //重写类或者接口中的方法
                          //也可自定义方法
                    };

     本质：其实就是继承了一个类或者实现了一个接口的匿名的子类对象

5、使用
     无论是匿名内部类还是匿名对象，一般使用方式
     1、只调用该类中的一个方法，这种情况一般该抽象类或者该接口只有一个抽象方法时使用
     2、作为实际参数传递(一般该匿名对象或匿名内部类中的方法不超过3个)

6、内部类命名规则

          成员内部类命名规则: 外部类$内部类.class

          局部内部类命名规则: 外部类$1第一级内部类$2第二级内部类$3第三级内部类.class，$后跟数字，数字与内部类对应的层级有关系

     匿名内部类命名规则: 外部类$1.class,1代表外部类下的第几个内部类

总结：

          $跟 类名 表示是成员内部类,

          $后面跟 数字 是匿名内部类，且数字代表个数,

          $后面跟 数字$类名 是局部内部类，数字表示层级

4、匿名内部类和匿名对象的区别

     不同点

          匿名内部类是一个继承了类或者实现了接口的子类对象

          而匿名对象就是这个类的本类对象  

     相同点

          都作为实际参数传递时使用，或者该对象的方法只调用 1次的时候使用

5、Scanner注意问题

1、Scanner中方法        

          next() -- 查找并返回来自此扫描器的下一个完整标记。
          nextLine() -- 此扫描器执行当前行，并返回跳过的输入信息。
          next() 和 nextLine() 区别：
               next()会将空格键、Tab键或Enter键等视为分隔符或结束符，不能得到带空格的字符串。
               nextLine()仅将Enter键作为结束符，返回Enter键前的所有字符，可以得到带空格。

2、案例

Scanner scanner = new Scanner(System.in);

int num = scanner.nextInt(); 

String str = scanner.nextLine();

System.out.println(num + str);

          1、问题描述

               当录入的顺序依次是int String,并且分别使用nextInt()和nextLine()方法获取数据的时候，会接受不到String数据     

          2、解决办法

               1、在录入完int后重新创建一个新的Scanner对象

               2、用字符串接受，然后把字符串转成int   

6、String类——构造方法

1、字符串概念

          由多个字符组成的一串数据。
2、构造方法

          创建字符串对象的几种方式

String s = new String();

通过字节数组创建字符串对象

String s = new String(byte[] bys);  

通过字节数组创建字符串对象常用

String s = new String(byte[] bys,int index, int length)

通过字节数组一部分创建字符串对象

String s = new String(char[] chs)

通过字符数组创建字符串对象常用

String s = new String(char[] chs, int index, int length);

通过字符数组一部分创建字符串对象

String s = new String(String); 

通过给构造方法传入字符串创建字符字符串对象

String s = “helloworld”

直接给字符串对象赋值常用

7、字符串的特点

     特点及注意事项

          字符串一旦被赋值，就不能改变。
          注意：字符串的值不能改变，引用是可以改变的。

8、String类——成员方法

1、判断功能

boolean equals(Object obj)

判断字符串的内容是否相同，区分大小写

boolean equalsIgnoreCase(String str)

判断字符串的内容是否相同，忽略大小写

boolean contains(String str)

判断字符串对象是否包含给定的字符串,区分大小写

boolean startsWith(String str)

判断字符串对象是否是以给定的字符串开始,区分大小写

boolean endsWith(String str)

判断字符串对象是否是以给定的字符串结束,区分大小写

boolean isEmpty()

判断字符串对象是否为空，注意是数据

2、获取功能

int length()

获取字符串长度

char charAt(int index)

返回字符串中给定索引处的字符

int indexOf(int ch)

返回指定字符在此字符串中第一次出现的索引

int indexOf(String str)

返回指定字符串在此字符串中第一次出现的索引

int indexOf(int ch,int fromIndex)

返回指定字符在此字符串中第一次出现的索引，从指定位置开始

int indexOf(String str,int fromIndex)

返回指定字符串在此字符串中第一次出现的索引，从指定位置开始

String substring(int start)

截取字符串，返回从指定位置开始截取后的字符串,原字符串长度不变

String substring(int start,int end)

截取字符串，返回从指定位置开始到指定位置结束，截取后的字符串原字符串长度不变

3、转换功能

byte[] getBytes()

把字符串转换成字节数组

char[] toCharArray()

把字符串转换成字符数组

static String copyValueOf(char[] chs)

把字符数组转换成字符串

底层调用new String(char[] chs)

static String valueOf(char[] chs)

把字符数组转换成字符串

底层调用new String(char[] chs)

static String valueOf(int i)

把int类型转换成字符串

String toLowerCase()

把字符变成小写原字符串不变

String toUpperCase()

把字符变成大写原字符串不变

String concat(String str)

字符串链接原字符串不变

4、其他功能

String replace(char oldChar,char newChar)

替换功能原字符串不变

String replace(String oldString,String newString)

替换功能原字符串不变

String[] split(String str)

切割功能原字符串不变

String trim()

去除字符串两端空格原字符串长度不变

int compareTo(String str)

字典顺序比较功能

int compareToIgnoreCase(String str)

字典顺序比较功能,不考虑大小写

9、数组操作

1、查找

普通查找
遍历数组，找到就返回索引

/**

        * 获取数组中指定元素的索引

        *

        * @param arr

        * @param value

        * @return

        */

       public static int getIndex(int[] arr, int value) {

              int index = -1;

              for (int x = 0; x < arr.length; x++) {

                     if (arr[x] == value) {

                            index = x;

                            break;

                     }

              }

              return index;

       }

折半查找
前提：数组必须有序  
只要中间索引对应的值与传入的值不相等
就拿中间索引对应的值和传入的值比较
如果中间索引对应的值比传入的值大，那么最小索引就应该是中间索+1
如果中间索引对应的值比传入的小，那么最大索引就应该是中间索引-1
为什么要+1,-1,因为中间索引对应的值不等于传入的值，
在下次遍历的时候就可以忽略该索引

最后判断最小值是否最大值       

public static intgetIndex(int[] arr, int value) {

              intmaxIndex = arr.length - 1;// 定义最大索引

              intminIndex = 0;// 定义最小索引

              intmidIndex = (maxIndex + minIndex) / 2;// 定义中间索引

 

              while(arr[midIndex] != value) {

                     if (arr[midIndex] > value) {

                            maxIndex = midIndex - 1;

                     } else if (arr[midIndex] < value) {

                            minIndex = midIndex + 1;

                     }

 

                     // 如果数据不存在。

                     if (minIndex > maxIndex) {

                            return -1;

                     }

 

                     // 下一次二分查找开始

                     midIndex = (maxIndex + minIndex) / 2;

              }

              returnmidIndex;

       }

2、排序

冒泡排序

A: 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

B: 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。

    在这一点，最后的元素应该会是最大的数。

C: 针对所有的元素重复以上的步骤，除了最后一个。

D: 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public static void bubbleSort(int[] arr) {

              // 外循环控制比较的次数

              for (int i = 0; i < arr.length - 1; i++) {

                     // 内循环控制每次比较中，元素两两比较的过程。每次需要比较的数据是逐渐减少的。

                     for (int j = 0; j < arr.length - 1 - i; j++) {

                            // 比较相邻元素，如果前面的大，进行交换

                            if (arr[j] > arr[j + 1]) {

                                   int temp = arr[j];

                                   arr[j] = arr[j + 1];

                                   arr[j + 1] = temp;

                            }

                     }

              }

       }

选择排序

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置

直到全部待排序的数据元素排完。 每次比较仅做一次交换

public static void selectionSort(int[] arr) {

              // 外循环控制比较的次数

              for (int i = 0; i < arr.length - 1; i++) {

                     // 定义变量，用于记录每次比较中最小值的索引

                     int mark;

                     // 内循环控制每次比较中，元素比较的过程。每次需要比较的数据是逐渐减少的。

                     for (int j = i + 1; j < arr.length; j++) {

                            mark = i;

                            if (arr[mark] > arr[j]) {

                                   mark = j;

                            }

                            // 判断，如果最小值不是每次比较时的第一个，将这个最小值交换到每次比较的起始索引处。

                            if (mark != i) {

                                   int temp = arr[i];

                                   arr[i] = arr[mark];

                                   arr[mark] = temp;

                            }

 

                     }

              }

       }

10、Arrays工具类

1、Arrays是针对数组操作的工具类

2、成员方法

public static String toString(数据类型[] 变量名)

把数组变成字符串

public static void sort(数据类型[] 变量名)

对数组进行排序

public static int binarySearch(int[] arr,int value)

二分查找

11、System类

1、系统类，提供了静态的变量和方法供我们使用

2、成员方法

public static void exit(int value)

退出jvm，非0表示异常退出

public static long currentTimeMillis()

返回当前系统时间的毫秒值

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

从指定源数的指定位置开始复制，赋值到目标数组的指定位置

12、StringBuffer类

1、概念

     字符串缓冲区类

2、机制

     StringBuffer采用的是缓冲区机制。

     一开始，首先开辟一些空间，然后，随着数据的增多，还可以继续开辟空间。这些操作针对的是同一个对象。

3、String和StringBuffer区别

     1、String一旦被创建就不能被修改，但是StringBuffer可以被修改

     2、StringBuffer采用的是缓冲区机制，随着数据的增多，还会继续开辟内存空间 

4、构造方法

StringBuffer()

初始化一个理论长度为16的空对象

StringBuffer(int capacity)

初始化一个理论长度为指定大小的空对象

StringBuffer(String str)

初始化一个内容为str的对象，理论长度为字符串的长度+ 16

5、成员方法

获取长度

public int length()

字符个数，实际长度

public int capacity()

字符容量，理论长度

添加功能

StringBuffer append(数据类型 变量名)

在结尾处添加

StringBuffer insert(int index, 数据类型 变量名)

在指定位置添加

删除功能

StringBuffer deleteCharAt(int index);

删除指定位置处的字符

StringBuffer delete(int start, int end)

删除指定开始位置和结束位置之间的字符

替换功能

StringBuffer replace(int start, int end, String str)

用指定字符串替start位置到end位置的内容，注意包左不包右

截取功能

public String substring(int start)

从索引为start处截取到结尾

public String substring(int start, int end)

从索引为start，截取到end。包左不包右

反转功能

public StringBuffer reverse()

将此字符序列用其反转形式取代

13、基本类型的包装类

1、概述

     基本类型的数据我们只能使用值，不能做更多的操作。为了方便我们操作，java就把每种基本类型进行了包装。提供方法供我们使用

2、基本类型和包装类的对应关系

     

byte

 

short

 

int

Integer

long

 

float

 

double

 

char

Character

boolean

 

3、Integer构造方法

Integer(int num)

 

Integer(String s)

S必须是一个由数字字符组成的字符串

4、String和int类型的转换

     1、String --> int    调用Integer类中的parseInt方法(常用)

          public static int parseInt(String s)

     2、int --> String 

          方法一：调用Integer中的toString()

                    public static String toString(itn i);

          方法二：调用String中的valueOf

                    public static String valueOf(int i)

          方法三：直接和空串连接

                    num +"";

5、JDK5以后的新特性

     1、自动装箱：     基本类型  赋值给 引用类型      Integer integer = 1;

     2、自动拆箱：     引用类型  赋值给 基本类型      int i = new Integer(2);

14、Date类

1、概述

Date表示特定的时间，精确到毫秒

2、构造方法&成员方法

构造方法

Date()

默认指定当前时间(常用)

Date(long time)

根据给定的毫秒生成一个时间(常用)

成员方法

public long getTime()

获取毫秒值(常用)

public void setTime(long time)

通过毫秒值设置日期

15、SimpleDateFormat类

1、概述

     DateFormat:对日期进行格式化的类，提供了对日期进行格式化和对字符串进行解析的功能

     SimpleDateFormat是DateFormat的子类

2、构造方法&成员方法

构造方法

SimpleDateFormat() 

无参的构造方法，采用默认日期格式(几乎不用)

SimpleDateFormat(String pattern)

有参构造，指定日期格式(常用)

成员方法

public final String format(Date date)

日期 -- >文本(常用)

public Date parse(String date)

文本 -- >日期

3、常用的模式字符串 & 组合

yyyy(四个小y)

年

MM(两个大M)

月

dd(两个小D)

月份中的天

HH(两个大H)

时

mm(两个小mm)

分

ss(两个小s)

秒

SSS(三个大S)

毫秒

常用的一个：yyyy-MM-dd HH:mm:ss:SSS

16、Calendar类

1、概述

日历类，时间处理类

 通过get(字段值) 可以获取到一个日历字段，字段值都是静态常量，比如Canlendar.DATE,Calendar.YEAR.....

 Calendar不能实例化，只能通过调用静态的方法getInstance()获取该类的对象(涉及到了单例)

2、成员方法

int get(日历字段)

根据给定的日历字段获取值

日历字段：Calendar.YEAR,Calendar.DATE….

void set(年,月,日)

给日历设定指定的年，月，日

add(日历字段,值)

给指定的日历字段添加或者减去给定的值。取决于值的正负