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);
    }