java笔记九——Object类与String类

一、object类

object类简述

Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

object类的本地方法

本地方法 : 方法的定义上使用关键字,是修饰符 native ,这个方法就是本地方法.

本地方法的特点 :

方法没有方法体
方法是C++语言编写的,Sun公司不开源
方法运行的时候,是一个独立的内存 (本地方法栈)
作用 : 凡是遇到本地方法,方法的作用是和本机的操作系统交互的

object类常用的方法

方法名称	类型	描述
public Object()	构造	构造器
public boolean equals(Object obj)	普通	对象比较
public int hashCode()	普通	取得Hash码
public String toString()	普通	对象打印时调用

当子类调用object类中的方法时通常会根据自己的需要去重写这些方法，如果不重写，就默认调用object类中的方法。

equals()方法

Java技术认为任何对象都具备比较性，Object类定义了方法equals()，作用就是用来比较对象的。方法结果是boolean值，对象相等就是true。

objecat类中equals()方法的特点

① Object类的方法源码

public boolean equals(Object obj){
    return this == obj ;
}

引用数据类型： == 就是比较对象的地址是不是相同的。基本数据类型是比较值。

② equals()：所有类都继承了Object，也就获得了equals()方法。因此可以重写。

只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。

③ 特例：当用equals()方法进行比较时，对类File、String、Date及包装类来说，是比较类型及内容而不考虑引用的是否是同一个对象。

原因：在这些类中重写了Object类的equals()方法。

④ 为了比较对象的内容是否相同，而不是比较对象的地址，子类需要重写equals()方法。定义自己的规则。

思考 : 对象的地址有可比性吗北京海淀区中关村南大街1号, 北京昌平区北大产业园路2号. 不能比较对象的地址,我们要重写equals方法,建立我们对象Person自己的比较形式

public class Person {
    private String name;
    private int age;
    public Person(){}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /**
     * 重写equals,建立Person对象自己的比较方式
     * 比较对象的age年龄,年龄相同返回true
     */

    public boolean equals(Object obj){
        //健壮性判断,如果obj对象的值是null,比较的另一个对象不存在
        if (obj == null){
            return false;
        }
        //判断this和参数obj是不是一个对象 "p1" 如果是,返回true
        //怎么确定this和obj是不是一个对象,内地地址要是一样
        if ( this == obj ) {
            return true;
        }
        //比较对象的年龄,this和obj
        //obj向下转型为Person,安全性判断
        if (obj instanceof  Person) {//obj是Person对象
            Person p = (Person) obj;
            return this.age == p.age;
        }
        //不是Person,没有可比性
        return false;
    }
}

与equals()的区别

1、== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址

2、equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。

3、具体要看自定义类里有没有重写Object的equals方法来判断。

4、通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

toString()方法

① toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

public String toString(); //结果是字符串,就是对象内地地址

输出语句中System.out.println(对象) 调用对象的toString()

System.out.println(对象) == System.out.println(对象.toString())

toString方法的结果是地址值，和开发没有任何的关系。我们需要的是重写父类的方法toStirng()，建立对象自己的字符串表现形式。

public class Person {
    private String name;
    private int age;
    public Person(){}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 重写了父类的方法toString()
     * 返回字符串
     * @return
     * 重写方法目标 : 方法中,返回类中成员变量的值
     */
    public String toString(){
        return name + "::" + age;
    }
}

二、String字符串类

概念

字符串对象,程序中定义""都是字符串对象,这个对象的使用频率最高.

字符串类 java.lang.String类,继承Object类,实现了三个接口.

程序中只要你写"里面任意"都是String类的对象.

字符串对象是常量,一旦创建不能修改.

字符串对象创建

public static void main(String[] args) {
    //字符串创建,2个方式
    //直接=创建
    String s = "abc";
    //使用构造方法创建
    String str = new String("aa");
}

直接 = 创建方式,代码少,书写简单,推荐使用
new String() 使用了构造方法的创建形式,代码大,不推荐使用

字符串的实现原理

字符串这个数据类,在Java中是不存在的,字符串的实现原理是用char[]数组表示.

"abc",使用数组char[] ch = {'a','b','c'} ;来表示.

JDK9版本之后,节约内存,char数组改变为了byte数组

JDK8版本以前都是char数组

private final char value[]; //JDK中String类的源码

数组的前面的修饰符final, 最终的数组,数组一旦建立,数组的地址就被锁死(常量)使用常量的原因,为了线程安全

字符串创建对象的区别

String str = "abc"; 
String str = new String("abc");

public class StringTest {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s1 == s2); //false

        System.out.println("==========");
        /**
         *  s3 = hello 内存中出现String对象,里面是char数组
         *  s3保存的是String对象
         *
         *  s4 = "hello" 和s3中的字符串在内存中的数组表现是一样的
         *  共用
         *  s3的内存地址,赋值给s4
         */
        String s3 = "hello";
        String s4 = "hello";
        System.out.println(s3 == s4); //true

        System.out.println("========");

        String s5 = "how";
        String s6 = "you";

        String s7 = "howyou";
        /**
         *   s7 == (s5+s6)   s5和s6是变量
         *   变量在编译的时候,javac不确定变量的计算结果是什么
         *   运行的时候,JVM会为 s5+s6的结果,新开内存空间
         */
        System.out.println(s7 == (s5+s6)); //false

        System.out.println("============");

        /**
         *  "how"+"you" 是常量,值在编译期间就已经确定
         *  运行,不会建立新的内存空间
         */
        System.out.println(s7 == ("how"+"you"));// true

        String s8 = "a"+"b"+"c";

    }

    public static void print(){
        //字符串的不变
        //abc内存是不会改变
        String s = "abc";
        System.out.println(s);
        //变量s,指向了新的字符串对象
        s = "bbc";
        System.out.println(s);
    }
}

String类的构造方法

String(byte[] b) 字节数组转成字符串,使用平台(操作系统)的默认字符集
String(byte[] b,int off,int,len) 字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数

String(byte[] b,int off,int,len,String,charsetName) 字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数,charsetName参数是你自己可以指定编码表

public class StringTest {
    public static void main(String[] args) throws UnsupportedEncodingException {
        stringConsByte3();
    }

    //String类构造方法相关,和字节,汉字相关
    public static void stringConsByte3() throws UnsupportedEncodingException {
        // String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //平台是操作系统, 默认字符集是GBK
        //强制指定为GBK编码
        byte[] bytes ={-28, -67, -96, -27};
        String str = new String(bytes,"gbk");
        System.out.println(str);
    }

    //String类构造方法相关,和字节,汉字相关
    public static void stringConsByte2(){
        // String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //平台是操作系统, 默认字符集是GBK
        //IDEA 启动的时候,为JVM添加启动参数,默认字符集改成UTF-8

        byte[] bytes ={-28, -67, -96, -27, -91, -67}; // 6字节的数组,转为字符串后是2个汉字
        String str = new String(bytes);
        System.out.println(str);
    }

    //String类构造方法相关,和字节
    public static void stringConsByte(){
       // String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //平台是操作系统, 默认字符集是GBK
        byte[] bytes = {97,98,99,100};
        String str = new String(bytes);
        System.out.println(str);

        //数组的一部分转成字符串
        String str1 = new String(bytes,1,2);//从1索引开始,要2个
        System.out.println(str1);
    }
}

String(char[] b) 字符数组转成字符串

String(char[] b,int off,int,len) 字符数组转成字符串,参数off数组的开始索引,len要转的个数

//String类的构造方法,new String(char[])
public static void stringConsChar(){
    char[] ch = {'a','b','c','d','e'};
    //构造方法,数组转成字符串
    String s = new String(ch);
    System.out.println(s);

    //构造方法,数组转成字符串,转一部分
    String s1 = new String(ch,1,3);//从1索引开始,转3个
    System.out.println(s1);
}

String类的判断类型的方法

String类的判断类型的方法, 返回都是布尔类型

boolean equals(Object obj) 字符串之间的比较,两个字符串相同,返回true
boolean equalsIgnoreCase(String str ) 字符串之间的比较,两个字符串相同,返回true,忽略大小写
boolean startWith(String str)判断字符串是否以另一个字符串开头,是开头就返回true
boolean endsWith(String str)判断字符串是否以另一个字符串结尾,是结尾就返回true
boolean contains(String str) 判断字符串中是否包含另一个字符串,完全包含返回true

boolean isEmpty()判断字符串的长度是不是0,如果是0返回true

public static void  stringMethod(){
        //boolean equals(Object obj) 字符串之间的比较,两个字符串相同,返回true
        //String类继承Object,重写父类方法,比较的是字符串的实际内容
        String s1 = new String("abc");
        String s2 = new String("abc");
        boolean b = s1.equals(s2);
        System.out.println(b);

        System.out.println("====================");
        //boolean equalsIgnoreCase(String str ) 字符串之间的比较,两个字符串相同,返回true,忽略大小写
        b = "abcdef".equalsIgnoreCase("ABCDEF");
        System.out.println(b);
        System.out.println("=============");
        //boolean startWith(String str)判断字符串是否以另一个字符串开头,是开头就返回true
        b = "HelloWorld.Java".startsWith("Hello");

        System.out.println(b);
        b = "HelloWorld.Java".endsWith(".Java");
        System.out.println("=============");
        System.out.println(b);

        //boolean contains(String str) 判断字符串中是否包含另一个字符串,完全包含返回true
       b = "how are you".contains("are  ");
        System.out.println("=============");
        System.out.println(b);

        //boolean isEmpty()判断字符串的长度是不是0,如果是0返回true
        b = "".isEmpty();
        System.out.println("=============");
        System.out.println(b);
    }

String类的获取方法

String类的获取方法,返回值不一定

int length() 返回字符串长度,字符串中字符的个数
char charAt(int index) 返回指定索引上的单个字符
int indexOf(String str) 返回指定的字符串,在当前字符串中第一次出现的索引
int lastIndexOf(String str) 返回指定的字符串,在当前字符串中最后一次出现的索引

String substring(int start,int end)截取字符串,参数表示开始索引和结束索引,包含开头索引,不包含结束索引

/**
     * String类的获取方法
     */
    public static void stringMethod2(){
        //int length() 返回字符串长度,字符串中字符的个数
        int length = "abcdef".length();
        System.out.println("length = " + length);

        //char charAt(int index) 返回指定索引上的单个字符
        char ch = "abcdef".charAt(3);
        System.out.println("ch = " + ch);

        //int indexOf(String str) 返回指定的字符串,在当前字符串中第一次出现的索引
        //找不到指定的字符串,返回-1  负数不能作为索引出现
        int index = "how do you do".indexOf(" ");
        System.out.println("index = " + index);

        //int lastIndexOf(String str) 返回指定的字符串,在当前字符串中最后一次出现的索引
        index = "how do you do".lastIndexOf(" ");
        System.out.println("index = " + index);

        //String substring(int start,int end)截取字符串,参数表示开始索引和结束索引,
        // 包含开头索引,不包含结束索引
        String str = "HelloWorld";
        str =  str.substring(2,6);// 返回新的字符串
        System.out.println("str = " + str);

        //substring具有重载写法
        String str1 = "你好我好大家好";
        str1 = str1.substring(3);//从3索引开始,截取到最后
        System.out.println("str1 = " + str1);
    }

String类的转换方法

String类的转换方法

String toLowerCase() 字符串中的所有内容转成小写
String toUpperCase() 字符串中的所有内容转成大写
char[] toCharArray() 字符串转成字符数组
byte[] getBytes() 字符串转成字节数组 (查询编码表),平台默认字符集
byte[] getBytes(String charsetName) 字符串转成字节数组 (查询编码表),指定编码表

static String valueOf(任意类型参数) 参数转成字符串对象

**
     * String类的转换方法
     */
    public static void stringMethod3() throws UnsupportedEncodingException {
        //- String toLowerCase() 字符串中的所有内容转成小写
        // - String toUpperCase() 字符串中的所有内容转成大写
        String str = "abCDefGHJktyM";
        String lower = str.toLowerCase();
        String upper = str.toUpperCase();
        System.out.println("lower = " + lower);
        System.out.println("upper = " + upper);

        //char[] toCharArray() 字符串转成字符数组
        char[] ch = str.toCharArray();
        System.out.println(ch);

        //byte[]  getBytes() 字符串转成字节数组 (查询编码表),平台默认字符集
        String s = "呵呵你好";
        byte[] bytes = s.getBytes("gbk");
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

       // static String valueOf(任意类型参数) 参数转成字符串对象
        int i = 1;
        String strI = String.valueOf(i);
        System.out.println(strI+1);
    }

String类的比较方法

String类的比较方法

String trim() 去掉字符串两边空格,中间空格不去掉
String replace(String oldString,String newString)替换字符串

String[] split("规则字符串") 对字符串进行切割

   /**
     * String类的方法 去空格,替换,切割
     */
    public static void stringMethod5() throws UnsupportedEncodingException {
        //String trim() 去掉字符串两边空格,中间空格不去掉
        String str = "  abc  def       ";
        System.out.println(str);
        str = str.trim();
        System.out.println("str = " + str);

        //String[] split("规则字符串") 对字符串进行切割
        String splitStr = "aa,bb,cc,dd,ee"; // 逗号,进行切割
        String[] strs = splitStr.split(",");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }

        //String replace(String oldString,String newString)替换字符串
        String repStr = "how do you do";
        repStr = repStr.replace("o","N");
        System.out.println("repStr = " + repStr);
    }

String类正则表达式相关的功能

正则表达式 : 专门用于处理字符串的技术 (正则大神)

常用的正则符号

字符类 :
- [abc] 字符串的这个位置只能是abc
- [^abc] 字符串的这个位置不能是abc
- [a-zA-Z] 字符串的这个位置必须是字母,52个
- [^a-zA-Z] 字符串的这个位置必须不能是字母,52个
数字类:
- [0-9] 字符串的这个位置只能是数字
- [^0-9] 字符串的这个位置不能是数字
- [d] 等同于 [0-9]
- [D] 等同于 [^0-9]
预定义字符 :
- . 匹配所有的字符
- [d] 等同于 [0-9]
- [D] 等同于 [^0-9]
- [w] 文字字符,包含数字,字母,下划线 [a-zA-Z0-9_]
- [W] 文字字符,不包含数字,字母,下划线 [^a-zA-Z0-9_]
数量词 :
- X{m} X这个字符只能出现m次 a{3}
- X{m,} X这个字符至少出现m次
- X{m,n} X这个字符至少出现m次,不超过n次
- X? X这个字符出现一次,或者一次也没有
- X* X这个字符出现零次或者多次
- X+ X这个字符出现至少一次

正则表达式的匹配功能

正则表达式的匹配功能,String类的方法matches()

/**
     *  检查邮箱
     *  规则 :
     * @ 前面 : 可以是数组,字母,混合,_  位数放下
     * @ 后面 : 数组,字母  sina qq 126 1393 yahoo gmail 位数放下
     * . 固定 : com  cn org  edu gov 字母  位数放下
     */
public static void stringMethod2(){
    String email = "shihehe@sina.com";
    String reg = "[\w]+@[a-z0-9]+(\.[a-z]+)+";
    boolean b = email.matches(reg);
    System.out.println(b);

}
/**
     *  正则表达式检查手机号是否合法
     *  开头必须是1,长度固定11
     *  第二位3 4 5 6 7 8 9
     *  第三位 必须是都是数字
     */
public static void stringMethod(){
    String tel = "13800138000";
    //定义正则的规则,也是字符串
    String regex = "1[3459678][0-9]{9}";
    //正则规则,和字符串校验
    //String类的方法 matches()
    boolean b = tel.matches(regex);
    System.out.println(b);
}

String类的方法split

String类的方法split

   public static void stringMethod3(){
        String str = "as123d387654w5465fasfr234567sa";
        String[] strings = str.split("\d+");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        System.out.println("================");
        String ip = "192.....168.....35.121";
        String[] ipArray = ip.split("\.+");
        for (int i = 0; i < ipArray.length; i++) {
            System.out.println(ipArray[i]);
        }
    }

String类的方法replaceAll

String类的方法replaceAll

public static void stringMethod4(){
        String str = "as123d387654w5465fasfr234567sa";
        //字符串中的所有数组,换成#
        String repString = str.replaceAll("\d+","#");
        System.out.println(repString);

        String first =  str.replaceFirst("\d+","#");
        System.out.println(first);
    }

三、StringBuilder类

概述

一个可变的字符序列，字符序列就是字符数组

String 类中 : private final char[] value;
StringBuilder : char[] value;

字符序列是数组，Java数组的是定长的，一旦创建，长度固定!

创建对象的时候,StringBuilder中的数组的初始化长度为16个字符

StringBuilder自动的进行数组的扩容，会创建一个新数组，原来数组的中元素复制到新的数组，再将变量指向新数组的地址，原来的数组会被垃圾回收器回收。

结论 : 无论怎么做字符串的操作，StringBuilder内部永远只有一个数组

StringBuilder类是线程不安全的类，运行速度快 , 后面我们多使用单线程，因此推荐使用StringBuilder。

StringBuffer是线程安全的类，运行速度慢。多线程的程序使用。

两个类的构造方法，和其他的方法，一模一样。

常用方法：append()

StringBuilder类的append(任意参数)。无论参数写的是什么，都可以变成字符串。

public static void builderAppend(){
    StringBuilder builder = new StringBuilder();
    //方法append追加字符串
    builder.append(100);
    builder.append(5.8);
    builder.append(true);
    System.out.println("builder = " + builder);
}

方法调用链, 链式编程:

链式编程 : 保证一个方法的返回值是一个对象,再使用这个对象调用的调用方法 :对象.方法().方法().方法()......

public static void builderAppend2(){
    StringBuilder builder = new StringBuilder();
    //方法append() 返回值是StringBuilder
    //return this 返回值是this (谁调用,我是谁)
    builder.append("hehe").append(false).append(1.5).append(1); //执行的结果,是builder对象,继续使用builder对象调用方法
    System.out.println("builder = " + builder);
}

常用方法：insert()

StringBuilder类的insert(索引,任意参数)。可以将任意类型的参数,插入到字符串缓冲区的指定索引位置。原有字符顺延。

/**
     * StringBuilder类的方法insert,指定位置,插入元素
     */
public static void builderInsert(){
    StringBuilder builder = new StringBuilder();
    builder.append("bcdef");
    //指定的索引上,添加字符串,原有字符,顺延
    builder.insert(2,"QQ");
    System.out.println("builder = " + builder);
}

StringBuilder类的其它方法

int length() 返回字符串缓冲区的长度
StringBuilder delete(int start,int end)删除缓冲区中的字符,包含开头索引,不包含结束索引
void setCharAt(int 索引,char ch)修改指定元素上的字符
StringBuilder reverse() 翻转字符串

StringBuilder对象与String对象的互转

String对象转成StringBuilder对象

方式一：StringBuilder类的构造方法： StringBuilder(String str)

方式二：append方法： append(String str)

/**
     * String -> StringBuilder
     */
    public static void stringToStringBuilder(){
        //构造方法
        StringBuilder builder = new StringBuilder("abc");
        //对象的方法append
        builder.append("hello");
    }

StringBuilder对象转成String对象

方式一：StringBuilder的方法：builder.toString()

方式二：String类的构造方法：new String(builder)

/**
     *  StringBuilder -> String
     */
    public static void stringBuilderToString(){
        StringBuilder builder = new StringBuilder();
        builder.append("我是字符串的缓冲区");
        //builder对象转成String对象,调用builder对象的方法 toString()
        String str = builder.toString();
        System.out.println(str);

        //String类的构造方法
        String s = new String(builder);
        System.out.println(s);
   }

四、System类

System系统类 : 定义在java.lang包中

定义了大量常用的字段(成员变量)和方法，该类不能实例化对象，即不能new。类中的成员全部都是静态修饰的，类名直接调用。

全部静态成员，无需创建对象，类名直接调用。构造方法private修饰

System类的方法

static long currentTimeMillis() 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值。 1000毫秒=1秒

/**
* static long currentTimeMillis()
* 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 ,
* 1000毫秒=1秒
*/
public static void systemCurrentTimeMillis(){
    long timeMillis = System.currentTimeMillis();
    System.out.println("timeMillis = " + timeMillis); 
}

static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )复制数组的元素.

src : 要赋值的数据源,源数组
srcPos : 源数组的开始索引
dest : 要复制的目标数组
destPos : 目标数组的开始索引
length : 要复制的元素个数

 
 public static void systemArraycopy(){
        int[] src = {1,3,5,7,9};
        int[] dest = {2,4,6,8,0};
        //数组元素的赋值 : src数组中的3,5 复制到dest数组中0索引开始
        System.arraycopy(src,1,dest,0,2);
        for(int x = 0 ;  x < src.length ;x++ ){
            System.out.println(dest[x]);
        }
    }

static Properties getProperties() 返回当前的操作系统属性

  /**
     *  static Properties getProperties() 返回当前的操作系统属性
     *  System.getProperty(String 键名)
     */
    public static void systemGetProperties(){
        Properties properties = System.getProperties();
        System.out.println(properties);
        String str = System.getProperty("os.name");
        System.out.println(str);
    }

五、Math类

static double PI 圆周率
static double E 自然数的底数
static int abs(int a) 返回参数的绝对值
static double ceil(double d)返回大于或者等于参数的最小整数（向上取整）
static double floor(double d)返回小于或者等于参数的最大整数（向下取整）
static long round(double d)对参数四舍五入
static double pow(double a,double b ) a的b次幂
static double random() 返回随机数 0.0-1.0之间（包左不包右）

static double sqrt(double d)参数的平方根

public static void main(String[] args) {
// System.out.println("Math.PI = " + Math.PI);
//  System.out.println("Math.E = " + Math.E);

//static int abs(int a) 返回参数的绝对值
System.out.println(Math.abs(-6));

//static double ceil(double d)返回大于或者等于参数的最小整数
System.out.println(Math.ceil(12.3)); //向上取整数

//static double floor(double d)返回小于或者等于参数的最大整数
System.out.println("Math.floor(5.5) = " + Math.floor(5.5));//向下取整数

//static long round(double d)对参数四舍五入
long round = Math.round(5.5); //取整数部分  参数+0.5
System.out.println("round = " + round);

//static double pow(double a,double b ) a的b次幂
System.out.println("Math.pow(2,3) = " + Math.pow(2, 3));

//static double sqrt(double d)参数的平方根
System.out.println("Math.sqrt(4) = " + Math.sqrt(3));

// static double random() 返回随机数 0.0-1.0之间
for(int x = 0 ; x < 10 ; x++){
System.out.println(Math.random()); //伪随机数
}

}

六、数组的相关操作

数组的翻转

所谓的数组的翻转例子 : 原始数组 {1,2,3,4} 翻转后是 {4,3,2,1}

数组的翻转不等于倒叙遍历

数组中元素位置的交换,数组的换位,借助一个变量

核心问题 : 数组中最远端的元素交换位置上

/**
* 数组的翻转
*/
public static void arrayReverse(){
    int[] arr = {1,2,7,5,0,22,3,4};
    //最远的元素,交换位置 (使用第三方变量)
    for(int min = 0 , max = arr.length -1;  min < max ; min++ ,max-- ){
    int temp = arr[min] ;//记录数组的最小索引上的元素
    arr[min] = arr[max] ; //数组最大索引上的元素,赋值到最小元素的位置上
    arr[max] = temp;
    }
    //遍历看结果
    for (int i = 0; i < arr.length; i++) {
    	System.out.println(arr[i]);
    }
}

数组的二分(折半)搜索法

数组的基本搜索法 : 判断一个元素是否存在于数组中。遍历数组,查找就可以

二分搜索法提高效率 : 前提是数组必须是有序的。

 /**
     * 数组的二分搜索法
     * 返回查找的元素在数组中的索引,没有呢返回负数
     */
    public static int binarySearch(int[] arr,int key){
        int min = 0 ; //数组的最小索引
        int max = arr.length - 1; //数组的最大索引
        int mid ;//数组折半后的,中间位置的索引
        //循环折半,次数不定,while循环
        //条件,,最小索引不能超过最大索引
        while (min <= max){
            //折半
            mid = (min + max) / 2;
            //折半后的mid作为索引,取出数组的元素,和关键字比较
            if (key > arr[mid])
                //移动最小索引
                min = mid + 1;
            else if (key < arr[mid])
                //移动最大索引
                max = mid - 1;
            else {
                //查找到了,返回索引
                return mid;
            }
        }
        return -1;
    }

数组的排序

在无序的数组中,对元素进行排序,默认都是升序. 效率

数组排序 : 元素在内存中的位置交换,效率最低.

冒泡排序,选择排序 (对冒泡的优化),插入排序,折半排序,希尔排序,快速排序

冒泡排序 (bubble)

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {8,12,25,6,13,5,14};
        bubbleSort(arr);
        System.out.print("排完序：" + Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {  // 当i = 0 时，数组内仅剩一个元素不必再遍历
            for(int j = 0;j<i;j++){     // j<i：防止数组角标越界异常
                if(compare(arr[j],arr[j+1])){   // 如果arr[j] 大于 arr[j+1] 就交换二者的位置
                    swap(arr,j,j+1);
                }
            }
        }
    }

    // 交换位置
    private static void swap(int[] arr, int j, int i) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 比较两个数的大小
    private static boolean compare(int i, int j) {
        return ( i - j) > 0;
    }
}

// 排完序：[5, 6, 8, 12, 13, 14, 25]

选择排序

对冒泡排序的优化

优化 : 不是每次比较完成都要换位,获取到最值,用这个最值在换位值

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {8, 12, 25, 6, 13, 5, 14};
        selectionSort(arr);
        System.out.print("排完序：" + Arrays.toString(arr));
    }

    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {  // arr.length - 1：防止内层循环出现数组角标越界的异常
            int min = i;    // 假定本次遍历的 索引 i 处是最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (compare(arr[min], arr[j])) {   // 如果arr[min]大于arr[j]，获取较小值的下标
                    min = j;
                }
            }
            // 内层循环结束后，获取到本次遍历的最小值的索引。
            swap(arr, i, min);
        }
    }

    // 交换位置
    private static void swap(int[] arr, int j, int i) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 比较两个数的大小
    private static boolean compare(int i, int j) {
        return (i - j) > 0;
    }
}

Arrays工具类

java.util包中定义了类Arrays，数组操作的工具类。类不能创建对象，直接静态调用。

Arrays类的静态方法
- static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
- static int binarySearch(数组,查找的关键字) 对数组进行二分搜索法
- static void fill(数组,填充的元素)，填充数组的所有元素
- static String toString(数组) 返回数组字符串表现形式
- static List asList(T...t) 元素转成List集合

    public static void main(String[] args) {
        int[] arr = {1,5,9,10,15,22,27,30};
        //arrayToString(arr);
       // arraySort(arr);
       // System.out.println(Arrays.toString(arr));

        int index = arrayBinarySearch(arr,5);
        System.out.println(index);

        arrayFill();
    }
    /**
     * fill填充数组
     */
    public static void arrayFill(){
        int[] arr = {1,2,3,4,5};
        Arrays.fill(arr,6);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * static int binarySearch(数组,查找的关键字) 对数组 进行二分搜索法
     * 返回元素在数组中出现的索引
     * 如果元素不存在,返回 (-插入点-1)
     * key : 放在数组中,保证有序的
     */
    public static int arrayBinarySearch(int[] arr,int key){
        int index = Arrays.binarySearch(arr, key);
        return index;
    }

    /**
     *  static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
     */
    public static void arraySort(int[] arr){
        Arrays.sort(arr);
    }

    /**
     * static String toString(数组) 返回数组字符串表现形式
     * toString内部自动遍历数组
     */
    public static void arrayToString(int[] arr){
        String str =  Arrays.toString(arr);
        System.out.println(str);
    }

七、字符串相关操作

字符串翻转

数组可以转成字符串,字符串也能转成数组

 /**
     * 翻转字符串的另一个实现
     */
    public static String  stringReverse2(String str){
        //str转成StringBuilder
        //StringBuilder builder = new StringBuilder(str);
       // builder.reverse();
        //字符串缓冲区转成字符串返回
        //return builder.toString();
       return   new StringBuilder(str).reverse().toString();
    }

    /**
     * 翻转字符串
     * 传递字符串,返回翻转后的字符串
     */
    public static String stringReverse(String str){
        //字符串转成数组
        char[] chars = str.toCharArray();
        //翻转数组
        for(int min = 0 ,max = chars.length - 1; min <= max ; max--,min++){
            char temp = chars[min];
            chars[min] = chars[max];
            chars[max] = temp;
        }
        //数组转成字符串
       return new String(chars);
    }

自定义trim()

去掉字符串两边的空格

" abcd efg " ==>"abcd efg"

/**
     *  自定义的方法trim()
     *  "    abcde  fg  "
     *  "abcde  fg  "
     */
    public static String myTrim(String str){
        //去掉字符串开头的空格,方法替换
        str = str.replaceFirst(" +","");
        //判断字符串,是不是以空格结尾
        while (str.endsWith(" ")){ //"abcde  fg1"
            //截取字符串
            str = str.substring(0,str.length()-1);
        }
        return str;
    }

统计字符出现的次数

要求 : 指定字符串 "asdfg3435erAAEExc" , 统计小写字母、大写字母、数字，各自出现了多少次，不考虑其它字符。

统计的案例 : 计数器思想变量++

实现思想 : 字符串换成数组,取出每个元素,分别统计 ASCII码熟悉

/**
     *  统计字符串中字符和数字出现的次数
     */
    public static void stringCount(String str){
        if (str == null)
            return;
        //定义三个计数器变量
        int upper = 0 , lower = 0 , number = 0;
        //字符串转成数组
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            //取出每个元素
            char ch = chars[i];
            //判断ch字符的ASCII范围
            if ( ch >= 'A' && ch <= 'Z')
                //大写字母
                upper ++;
            else if ( ch >= 'a' && ch <= 'z')
                //小写字母
                lower ++;
            else if (ch >= '0' && ch <= '9'){
                //数字
                number ++;
            }
        }
        System.out.println("大写字母:"+upper);
        System.out.println("小写字母:"+lower);
        System.out.println("数字:"+number);
    }

统计字符串出现的次数

要求：字符串A,另一个字符串B,计算B字符串在A字符串中出现几次

实现过程：

对字符串进行索引查找 indexOf
找到的字符串的索引记录,进行字符串的截取
直到 indexOf方法是-1
一旦找到了,计数器++

/**
     * @param str  原始字符串
     * @param sub  要查找的字符串
     * @return  出现次数
     */
    public static int stringCount(String str ,String sub){
        //定义变量,计数器
        int count = 0;
        //定义变量,记录字符串查找后的索引
        int index = 0;

        //对字符串出现的位置,进行查询
        //反复查找,使用循环while
        //循环条件就是indexOf方法返回-1
        while ( (index=str.indexOf(sub))  != -1 ) {
            //执行了循环index !=-1 字符串出现了
            count ++;
            //截取字符串,开始索引 index+被查找字符串的长度
            str = str.substring(index + sub.length());
        }

        return count;
    }

统计哪个字符出现的次数最多

要求 : 指定字符串只能是(小写)字母 abeegewff , 计算出哪个字符出现的次数最多

限定字符串中字母只能有26个

找每个字符各自出现多少次,找出最大值

实现过程 :
- 字符串转成数组 (单个字符操作)
- 创建长度为26的数组,计数器使用
- 取出数组中的字符, (字符-97)对应数组的索引,计数器++
- 找出数组中的最大值

    /**
     * 查找字符串中,哪个字符出现的次数最多
     * @param str  要查找字符串
     * @return  返回出现次数最多的字符
     */
    public static char charCount(String str){
        //字符串转成数组
        char[] chars = str.toCharArray();
        //定义26长度的数组,保存每个字符出现的次数
        int[] count = new int[26];
        //遍历数组
        for (int i = 0 ; i < chars.length; i++){
            //取出单个字符
            char ch = chars[i];
            //字符 - 97 作为数组的索引使用 (数组,计数器数组)
            count[ ch - 97 ] ++;
        }
        //System.out.println("Arrays.toString(count) = " + Arrays.toString(count));
        //取出count数组中的,最大值的索引
        int index = 0 ; //数组最大值索引
        int max = count[0];
        for(int i = 1 ; i < count.length ; i++){
            if (max < count[i]){
                index = i;
                max = count[i];
            }
        }
       //index索引,正好和字符相差97
        return (char) (index+97);
    }

java笔记九——Object类与String类

一、object类

object类简述

object类的本地方法

object类常用的方法

equals()方法

objecat类中equals()方法的特点

与equals()的区别

toString()方法

二、String字符串类

概念

字符串对象创建

字符串的实现原理

字符串创建对象的区别

String类的构造方法

String类的判断类型的方法

String类的获取方法

String类的转换方法

String类的比较方法

String类正则表达式相关的功能

常用的正则符号

正则表达式的匹配功能

String类的方法split

String类的方法replaceAll

三、StringBuilder类

概述

常用方法：append()

常用方法：insert()

StringBuilder类的其它方法

StringBuilder对象与String对象的互转

String对象转成StringBuilder对象

StringBuilder对象转成String对象

四、System类

System类的方法

五、Math类

六、数组的相关操作

数组的翻转

数组的二分(折半)搜索法

数组的排序

冒泡排序 (bubble)

选择排序

Arrays工具类

七、 字符串相关操作

字符串翻转

自定义trim()

统计字符出现的次数

统计字符串出现的次数

统计哪个字符出现的次数最多

七、字符串相关操作