柘明Java笔记9

第五章 常用类

Java API概述

API(Application Programming Interface)应用程序编程接口,是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明.

基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个基本数据类型对应的类统称为包装类. 包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法.

对于包装类来说，这些类的用途主要包含两种：1.作为和基本数据类型对应的类类型存在。包含每种基本数据类型的相关2.属性如最大值、最小值等，以及相关的操作方法.

//包装类常用属性方法:
//以下方法以java.lang.Integer为例
public static final int MAX_VALUE 最大的int型数（231-1）
public static final int MIN_VALUE 最小的int型数（-231）
//构造方法
Integer(int a);
Integer(String a);
//比较方法
static int compareTo(Integer a);
boolean equals(Object);
int max(int a,int b);
int min(int
//转换方法
static toBinaryString(int i);
static String toHexString(int i);
static String toOctalString(int i);
int intValue();
static int parseInt(String s);
String toString();
static Integer valueOf(int i)
static Integer valueOf(String s)
//装箱和拆箱Auto-boxing/unboxing
//装箱:自动将基本数据类型转换为包装器类型,装箱的时候自动调用的是Integer的valueOf(int)方法
//拆箱:自动将包装器类型转换为基本数据类型,拆箱的时候自动调用的是Integer的intValue方法
//装箱
int a = 12;
Integer b = Integer.valueOf(a);
//拆箱
int c = b.intValue();
int a = 12;
//自动装箱,自动装箱: 把基本类型转为包装类型Integer.valueOf(y)
Integer b =a;
//自动拆箱,自动拆箱: 把包装类型转为类型 x.intValue()
int c = b;

public static void main(String[] args) {
        int a = 10;//基本类型结构很简单,但是不利于面向对象的编程
        //java中为每种基本类型提供了一个包装类,在类中包含着一个基本类型成员变量
        //在包装类中就可以提供关于对int整数操作的方法
​
public static void main(String[] args) {
        //     包装类:  为基本类型提供一个类.类中包含一个基本类型成员   
        int a = 10;
        Integer b = new Integer(30);
            int c = b.intValue();//将对象中包装的基本类型取出来
          float d = b.floatValue();
        Integer b1 = new Integer(20);
        System.out.println( b.compareTo(b1));//比较两个对象中包含的基本类型值大小  返回-1,0,1
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.max(10,5));
        System.out.println(Integer.min(10,5));
        System.out.println(Integer.toHexString(220));
        System.out.println(Integer.toOctalString(9));
        System.out.println(Integer.toBinaryString(5));   }
       
   public static void main(String[] args) {
        //  == 比较基本类型时,比较的就是值是否相等
        int x = 128;
        int y = 128;
        System.out.println(x==y);//true
        //new  两个对象
        Integer i = new Integer(10);
        Integer ii = new Integer(10);
        System.out.println(i==ii); //两个对象的地址不同的
        //自动装箱
        Integer a = 128;// Integer.valueOf(128) 大于127 小于-128 就会new 新的对象
        Integer b = 128;//new
        //==  比较引用类型时,比较的是两个引用所指向的对象地址是否相同
        System.out.println(a==b);
        System.out.println(a.equals(b));//比较的是对象中的值是否相等
  /*     知道什么是基本类型包装类?
          为什么要有基本类型的包装类?
          包装类都有哪些需要关注的方法?
               1.简单的工具方法
               2.涉及到类型转换:  基本类型转为引用类型new Integer(10); valueOf(128)
                    引用类型转为基本类型intValue()
                    字符串类型转为基本类型  int  parseInt("30");
                    自动拆箱: 包装类型--->基本类型
                    自动装箱: 基本类型--->包装类型
 注意: 底层实现valueOf(128),将-128 -- +127做了缓存数组,在此区间的之间从缓存中获取,在此区间之外重新new 对象
                 ==  比较引用类型比较的是对象的内存地址
                 比较对象中包含的值是否相等 使用equals()方法    */
        Long l = 10L;
        Boolean bl  = true;
        boolean b2 = bl;  }}

Object类

Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都实现这个类的方法。如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类. public class Person { ... }等价于：public class Person extends Object {... } toString方法: Object类中定义有public String toString()方法，其返回值是 String类型，描述当前对象的有关信息。 在进行String与其它类型数据的连接操作时（如：System.out.println(“info”+person）），将自动调用该对象类的toString()方法,可以根据需要在用户自定义类型中重写toString()方法. equals方法: Object类中定义有 public boolean equals(Object obj)方法,提供定义对象是否“相等”的逻辑。 1.Object 的 equals 方法 定义为：x.equals ( y ) ，当 x 和 y是同一个对象的引用时返回 true 否则返回 false 2.JDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回true 否则返回 fals java.util.Arrays类: 用于操作数组工具类，里面定义了常见操作数组的静态方法。 equals 方法: 比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。 声明：public static boolean equals(type[]a,type[]a2) 参数的类型可以是原生数据类型和引用类型的任意一种类型。 返回：如果两个相等，则返回true，否则返回false.

public class ObjectDemo2 extends Object {
​
    /*   Object 是所有类的父类
        Object 实现多态的实现基础
         Object中方法:
            toString(); 将xxx转为字符串形式   Arrays.toString(a)
            equals()
            hashCode()
            wait()
            finalize()
            clone()....   */
 public static void main(String[] args) {
   /*    要对对象进行输出,默认会调用类中的toString()返回对象的字符串表示形式。
           Car类中没有toString(),会去调用父类中toString()
            public String toString() {          将对象内存地址(哈希值),转为16进制
                return getClass().getName() + "@" + Integer.toHexString(hashCode()); } */
        Car c = new Car("宝马", 30000);
        Car c1 = new Car("宝马", 30000);
    /*   public boolean equals(Object obj) {
           return (this == obj); } */
        System.out.println(c.equals(c1));//false  原因是Car类中没有重写equals(),调用Object类中的方法
        System.out.println(c==c1);//false
        Integer i = new Integer(10);
        Integer ii = new Integer(10);
        System.out.println(i.equals(ii));//true
        /*   == 引用类型比较,比较对象地址是否相等
           equals()比较的是对象中的内容是否相等   */
        System.out.println(c);//com.ffyc.javaapi.obj.Car@1b6d3586
        int[] a = new int[]{1,2,3,4,5};
        System.out.println(a);//[I@4554617c

Arrays类

sort －排序 1.作用于数组的所有元素public static void sort(type[] a) 2.作用于数组指定范围内的元素 public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))将指定的类型（除boolean以外的任意原生数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。 object型数组，根据元素的自然顺序，对指定对象数组进行升序排序。（fromIndex==toIndex，则排序范围为空） 自定义对象排序:自定义类实现Comparable接口,重写compareTo方法.

binarySearch -使用二分搜索算法搜索指定数组 声明： public static int binarySearch(type[] a, type key) public static int binarySearch(long[] a,int fromIndex,int toIndex,long key) 描述：使用二分搜索算法搜索指定的type型数组，以获得指定的值。 参数： a - 要搜索的数组。 key - 要搜索的值。 fromIndex - 要排序的第一个元素的索引（包括）。 toIndex - 要排序的最后一个元素的索引（不包括）。 type -byte、double、float、object、long、int、short、char 如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)

toString() 方法 声明：public static String toString(type[] a) 描述：返回指定数组内容的字符串表示形式。 基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“,”(逗号加空格)分隔.

//  Arrays类中提供一些关于数组操作的方法(例如排序,二分查找)
  public static void main(String[] args) {
        int[] a = new int[]{1,2,3,4,5};//new
        int[] b = new int[]{1,2,3,4,5,6};
        System.out.println(a==b);//false
        //equals(a1,a2)比较两个数组的内容是否相等
        System.out.println(Arrays.equals(a, b));
        //toString(a)将数组对象内容以字符串形式输出
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));   }}
public static void main(String[] args) {
        //int[] a = new int[]{5,3,4,2,1};
        //Arrays.sort(a);//引用传递 0,length-1
        //Arrays.sort(a,2,4);//sort(数组,开始位置(包含),结束位置(不包含的))
       // System.out.println(Arrays.toString(a));
        Car c0 = new Car(123, "宝马0");
        Car c1 = new Car(124, "宝马1");
        Car c2 = new Car(125, "宝马2");
        Car c3 = new Car(126, "宝马3");
        Car c4 = new Car(127, "宝马4");
        Car [] cars =  new Car[5];
               cars[0] = c2;
               cars[1] = c0;
               cars[2] = c4;
               cars[3] = c1;
               cars[4] = c3;
        Arrays.sort(cars);//对引用类进行排序,需要特殊处理一下
        System.out.println(Arrays.toString(cars));
        String []s = {"c","d","a", "b"};
        Arrays.sort(s);//String类已经实现了Comparable接口,可以排序
        System.out.println(Arrays.toString(s));  }
public static void main(String[] args) {
  /*     二分查找/折半查找,提高查询效率
            查询数组中有没有指定的元素
            二分查找前提是数组是有序的   */
        int[] a = new int[]{5,3,4,2,1,7,6};
         Arrays.sort(a);//1,2,3,4,5,6,7
         //int index = Arrays.binarySearch(a, 4); //index不是负数,说明找到了
         int index = Arrays.binarySearch(a, 0,4,7); //index不是负数,说明找到了
         System.out.println(index);  }
public static void main(String[] args) {
 /*   数组特点: 创建时必须给予长度,长度一旦定义不能修改了,空间是连续
       5  10
       数组复制: 将原来数组的内容复制到一个新的指定长度的数组中,称为数组扩容 */
          int a[] = new int[]{1,2,3,4,5};
          int [] b=Arrays.copyOf(a, 10); //数组扩容
          System.out.println(Arrays.toString(b));
         /* int b[] = new int[7];
          for (int i = 0; i < a.length; i++) {
             b[i] = a[i];
          }*/    }
public class Car implements Comparable<Car>{
     private int no;
     private String name;
    public Car(int no, String name) {
        this.no = no;
        this.name = name;   }
    @Override
    public String toString() {
        return "Car{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
 // 此方法是用于引用类型排序时,自定义排序规则的,此方法在底层源码中调用
    @Override
    public int compareTo(Car o) {
        return this.no-o.no;  }}// return this.name.compareTo(o.name);

String类/StringBuffer类/StringBuilder类

String类概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例. 有两种创建形式： 第一种:String s = "abc";先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建. 第二种: 一概在堆中创建新对象，值存储在堆内存的对象中。String s = new

构造方法 public String() public String(String str) public String(byte[] bytes) public String(char[] value

判断功能 boolean equals(Object obj) boolean equalsIgnoreCase(String str) boolean contains(String str) boolean isEmpty() boolean startsWith(String prefix) boolean endsWith(String suffix)

获取功能 int length() char charAt(int index) int indexOf(String str) int indexOf(String str,int fromIndex) String substring(int start) String substring(int start,int end)

转换功能 byte[] getBytes() char[] toCharArray() static String valueOf(char[] chs) String toLowerCase() String toUpperCase() String concat(String str) Stirng[] split(分割符);

替换功能 String replace(char old,char new) String replace(String old,String new) replaceAll(String regex, String replacement) replaceFirst(String regex, String replacement) 去除字符串两空格 String trim()

/*      java中所有的字符串 "",都可以视为String类的实例,
          String对象的值一旦定义就不能改变,底层是使用char数组存储
          private final char value[];   */
    public static void main(String[] args) {
        String s = "abcd"; //a,b,c,d  第一个字符串对象
               s +="efg";  //a,b,c,d,e,f,g 第二个字符串对象
        System.out.println(s);
        /*    创建字符串对象两种方式
           方式1: String s = "abcd";
            隐式创建,字符串对象直接在字符串常量池中存储,如果值相同,就直接返回字符串常量池中的对象地  */
        String s1 = "abcd";//隐式的创建了一个字符串对象
        String s11 = "abcd";
        System.out.println(s1==s11);//true
        System.out.println(s1.equals(s11));//true
   /*     方式2: 通过new创建
                 new 会在堆中创建不同的对象  */
        String s2 = new String("abcd");
        String s22 = new String("abcd");
        System.out.println(s2==s22);//false
        System.out.println(s2.equals(s22));  }}//true
​
  public static void main(String[] args) {
        String s = new String(); // ""
        String s1 = new String("abcd");
​
        // 判断功能
        String s2 = new String("abcd");
          System.out.println(s1.equals(s2));//true  比较字符串内容是否相等
        String s3 = new String("abcD");
        System.out.println(s2.equals(s3));
        System.out.println(s2.equalsIgnoreCase(s3));//比较时忽略大小写
        System.out.println(s3.contains("aD"));//是否包含指定的子串
        String s4 = "";//null ""
        System.out.println(s4.isEmpty());//""
        System.out.println(s3.startsWith("ac"));//判断以xxx开头(子串)
        System.out.println(s3.endsWith("cD")); }}
public static void main(String[] args) {
 /*      int length()
        char charAt(int index)
        int indexOf(String str)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)   */
        String s  = "abcdefgc";
                   //01234567
        System.out.println(s.length());//返回字符串长度
        System.out.println(s.charAt(3));//返回指定位置上的字符
        System.out.println(s.indexOf("c"));//获取指定字符首次出现的位置  从前向后
        System.out.println(s.indexOf("c",s.indexOf("c")+1));//从指定位置开始找的
        System.out.println(s.lastIndexOf("c"));//从后向前找
        System.out.println(s.substring(2));//从指定的位置开始截取一个新的子串到结尾
        System.out.println(s.substring(2,6));//从指定的位置开始截取一个到指定位置新的子串   }}

StringBuffer类