Java学习第十七章字符串/static关键字/Arrays/Math

最新推荐文章于 2022-05-02 23:33:59 发布

Z知行T

最新推荐文章于 2022-05-02 23:33:59 发布

阅读量335

点赞数

分类专栏： Java 学习文章标签： java

本文链接：https://blog.csdn.net/qq_40027172/article/details/106565126

版权

Java 学习专栏收录该内容

35 篇文章 0 订阅

订阅专栏

第十七章

一、字符串概述和特点

概述和特点

java.lang.String类代表字符串。
API当中说：Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
程序冲所有双引号的字符串，都是String的对象

字符串的特点：
1.字符串的内容用不可变【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

字符串构造方法和直接创建

创建字符串常见的3+1种方式：
public String():创建一个空白字符串，不含有任何内容。
public String (char[] array)
public String (byte[] array):根据字节数组的内容，来创建对应的字符串
一种直接创建:
String str = "hello";右边直接用双引号
注意：直接写上双引号，就是字符串对象。

public class Demo01String {
    public static void main(String[] args) {
        //使用空参构造
        String str1 = new String();///括号留空。什么内容都没有
        System.out.println("第一个字符串"+ str1);

        //根据字符数组创建字符串
        char[] charArray = new char[]{'A','B','C'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串"+str2);

        //根据字节数组创建字符串
        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println("第三个字符串" + str3);

        //直接创建
        String str4 = "hello";
    }
}

字符串常量池

·字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中（在堆当中）
对于基本类型来书：==是进行数值的比较
对于引用类型来水：==是进行【地址值】的比较
双引号直接写的字符转在常量池当中，new的不在池当中

public class Demo02StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);
		//比较的是地址值
        System.out.println(str1 == str2);//true
        System.out.println(str1 == str3);//false
        System.out.println(str2 == str3);//false

    }
}

在这里插入图片描述

字符串的比较相关方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：
public boolean equals(object obj)"参数可以是任何对象，只有参数是一个字符	串，并且内容相同才会给true，否则返回false。
注意事项：
1.任何对象都能用Object进行接收
2.equals方法具有对称性a.equals(b)和b.equals(a)效果一样
3.如果比较双方一个常量一个遍历，推荐把常量字符串写在前面
推荐："abv".equals(str) 不推荐str.equals("abc")

public boolean equalsIgnoreCase(String str) 忽略大小写进行比较

public class Demo01StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charAray = {'H','e','l','l','o'};
        String str3 = new String(charAray);

        System.out.println(str1.equals(str2));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals("Hello"));//true
        System.out.println("Hello".equals(str1));//true

        String str4 = "hello";
        System.out.println(str1.equals(str4));//false

        String str5 = "abc";
        System.out.println("abc".equals(str5));//推荐
        System.out.println(str5.equals("abc"));//不推荐，变量为null时会出现空指针异常


        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB));//false
        System.out.println(strA.equalsIgnoreCase(strB));//ture，忽略大小写进行比较




    }
}

字符串的获取相关方法

String当中与获取相关的常用方法有：
public int length();获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str) 将当前字符串和参数字符串拼接成为新的字符串：
public char charArt(int index): 获取指定索引位置的单个字符，（索引从零开始）
public int indexOf(String str) :查找参数字符串在本字符串当中首次出现的索引位置，若果没有返回-1值

public class Demo02StringGet {
    public static void main(String[] args) {
        //获取字符串长度
        int length = "asdasfdadasfgasfaf".length();
        System.out.println("字符串的长度是" + length);

        //拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str3);//HelloWorld
        System.out.println(str1);//Hello
        System.out.println(str2);//World

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

        //获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println(ch);
        System.out.println("----------------");

        //查找参数字符在本来字符串当中出现的第一次索引位置
        //如果没有，返回-1值
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是" + index);

        System.out.println("HelloWorld".indexOf("abc"));//-1 没找到

    }
}

字符串的截取相关方法

	字符串截取方法：
public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin ,int end):截取从begin开始一直到end结束，中间的字符串
备注：begin[begin,end)包含左边，不包含右边

public class Demo03SubString {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String sub = str1.substring(5);
        System.out.println(sub);//World  产生的新字符串
        System.out.println(str1);//HelloWorld 字符串不能发生改变

        System.out.println("-----------------");
        //截取中间一段
        String str3 =str1.substring(4,7);
        System.out.println(str3);

        //下面这种写法，字符串的内容仍然是没有改变的
        //下面有两个字符串："Hello" ，"Java"
        //strA中保存的是地址值
        //本来地址值是Hello的0x666,后来变成了Java的0x999
        String strA = "Hello";
        System.out.println(strA);//"Hello"
        strA = "Java";
        System.out.println(strA);//"java"

    }
}

字符串的转换相关方法

String当中与转换相关的常用方法有：

public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值
public byt[]  getByte();获得当前字符串底层的字节数组
public String replace(CharSequence oldString , CharSequence new String ):\
将所有出现的老字符串替换成为新字符串，返回替换后的新字符串
备注：CharSequence的意思就是说，可以接受字符串类型

public class Demo04StringConvert {
    public static void main(String[] args) {
        //将当前字符串拆分成为字符数组作为返回值
        String str1 = "HelloWorld";
        char[] chars = str1.toCharArray();
        System.out.println(chars.length);//10
        System.out.println("---------------");

        //转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);

        }
        System.out.println("---------------");
        //字符串的内容替换
        String str = "How do you do?";
        String str2 = str.replace("o", "*");
        System.out.println(str);//How do you do?
        System.out.println(str2);//H*w d* y*u d*?

        String lang1 = "会不会玩啊！ 你大爷的！ 你大爷的！";
        String lang2= lang1.replace("你大爷的", "******");
        System.out.println(lang2);//会不会玩啊！ ******！ ******！



    }
}

字符串的分割方法

分割字符串的方法：

public String[] split(String regex) :按照参数的规则，将字符串切分成为若干部分

注意事项：
split方法的参数其实是一个”正则表达式“,今后学习
今天注意，如果按照英文句点”.”进行切分，必须写“\\.”（两个反斜杠）

public class Demo05StringSplit {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] arry1 = str1.split(",");
        for (int i = 0; i < arry1.length; i++) {
            System.out.println(arry1[i]);

        }

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

        String str2 = "aaa bbb ccc";
        String[] arry2 = str2.split(" ");
        for (int i = 0; i < arry2.length; i++) {
            System.out.println(arry2[i]);

        }
        System.out.println("--------------");

        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\\."); //应该写\\.  不能只写.
        System.out.println(array3.length);//0
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);

        }


    }
}

字符串练习题

练习一：

定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。
格式为：[word1#word2#word3]

/*
分析
1.首先准备一个int[]数组，内容是1，2，3
2.定义一个方法将数组变成字符串
三要素：
返回值类型：String
方法名称：fromArrayToString
参数列表：int[]
3.格式：[word1#world2#world3]
用到for 循环、字符串拼接、每个数组元素前都有一个word字样、分隔符使用的是#、区分一下是不是最后一个
4.调用方法得到返回值，并打印结果字符串

 */

public class Demo06StringPractice {
    public static void main(String[] args) {
        int[] array = {1,2,3};

        String str = fromArrayToString(array);
        System.out.println(str);



    }

    public static String fromArrayToString(int[] array){
        String str = "[";
        for (int i = 0; i < array.length; i++) {

            if (i == array.length - 1){
                str += "word" + array[i] +"]";
            }else{
                str +="word"  + array[i] + "#";
            }


        }

                 return str;

    }
}

练习一：

键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他

键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他

思路：

1.用到键盘输入肯定是Scanner
2.键盘输入的是字符串String str = sc.next();
3.定义四个变量出现的次数
4.需要对字符串逐字检查。String-->char[]，方法就是toCharArray
5.遍历char[]字符数组。对当前字符种类进行判断，并且用四个变量进行++动作
6.打印输出四个变量

public class Demo07StringCount {
    public static void main(String[] args) {
        int num = 0;
        int lowerCase = 0;
        int other = 0;
        int upperCase = 0;


        Scanner sc = new Scanner(System.in);
        String input = sc.next();//获取键盘输入数字

        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i];

            if('A' <= ch && ch <= 'Z'){
                upperCase++;
            }else if ('a'<= ch && ch <= 'z'){
                lowerCase++;
            }else if ('0' <= ch && ch <= '9'){
                num++;
            }else {
                other++;
            }



        }
        System.out.println("大写字母有" + upperCase);
        System.out.println("小写字母有" + lowerCase);
        System.out.println("数字有" + num);
        System.out.println("其他有" + other);

    }
}

二、static概述和特点

静态Static关键字概述

在这里插入图片描述

静态Static关键字修饰成员变量

如果一个成员变量使用了static关键字,那么这个变量不再属于自己而是属于所在的类。多个对象共享

public class Student {
    private int id;
    private String name;
    private int age;
    private  static int idCounter = 0; //学号计数器

    static String room;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;//每创建一个对象学号加一
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


}

public class Demo01StaticField {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
         stu1.room = "37班";

        System.out.println("姓名:"+ stu1.getName() +",年龄"+stu1.getAge() +
                "，教室:"+stu1.room + ",学号" + stu1.getId());


        Student stu2 = new Student("李四",20);
        System.out.println("姓名:"+ stu2.getName() +",年龄"+stu2.getAge()
                + "，教室:"+stu2.room+ ",学号" + stu2.getId());



    }
}

静态Static关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类的
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它

无论是成员变量还是成员方法，如果有了static，都推荐使用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称静态方法（）

注意事项：

1.静态不能直接访问非静态
原因：内存当中是现有的静态内容，后有的非静态内容
2.静态方法中不能用this
原因：this代表当前对象，通过谁调用方法，谁就是当前对象

public class Demo02StaticMethod {
    public static void main(String[] args) {
        myClass obj = new myClass();//首先创建对象
        //然后才能使用没有static修饰的方法
        obj.method();

        //对于静态方法来说。可以通过对象名进行调用，也可以直接通过类名称来进行调用
        obj.methodStatic();//正确，不推荐 这种写法在编译后也会被javac翻译成为“类名称.静态方法”
        myClass.methodStatic();//推荐写法 。
        
        myMethod();//对于同类中的静态方法可省略类名称
        Demo02StaticMethod.myMethod();//等同

    }
    
    public static void myMethod(){
        System.out.println("同类中的方法！");
    }
}

public class myClass {
    int num;//成员变量
    static int numStatic;//静态成员变量

    //成员方法
    public  void method(){
        System.out.println("普通的成员方法");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    //静态方法
    public  static void methodStatic(){
        System.out.println("静态方法");
        //静态方法可以访问静态变量
        System.out.println(numStatic);
        //静态方法不能访问成员变量 会报错
      //  System.out.println(num);//错误写法
     //   System.out.println(this);//错误写法
    }
}

静态Static内存图

在这里插入图片描述

静态代码块

静态代码块：
public class 类名称{
static{
//静态代码块内容
}
}
特点：当第一次用到本类时，静态代码执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：
用来一次性的对静态变量进行赋值

public class Person {
    static {
        System.out.println("静态代码块");
    }

    //
    public Person(){
        System.out.println("构造方法执行啦");
    }

}

public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作
public static String toString(数组):将参数数组变成字符串（按默认格式：【元素1，元素2.。。】）
public static void sort(数组)：按照默认升序（从小到大）对数组元素进行排序
备注：
1.如果是数值。sort默认按照升序
2.如果是字符串，sort默认按照字母升序
3.如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {1,2,3};
        //将int数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);

        int[] array1 = {2,8,6,4,10,3};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[2, 3, 4, 6, 8, 10]

        String[] array2 = {"bbb","ccc","aaa"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));//[aaa, bbb, ccc]



    }
}

Arrays练习题

请使用Arays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印

public class Demo02ArraysPractice {
    public static void main(String[] args) {
        String str = "13524";
        //升序排列

        //必须是一个数组才能用Arrays.sort方法
        //String-->数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列

        //需要倒序遍历  .forr 是倒序  fori 是正序
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
            
        }
    }
}

数学工具类Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法完成与数学相关的操作

public static double abs(double num):获取绝对值
public static double ceil(double num):向上取整
public static double floor(double num):向下取整
public static long round(double num):四舍五入

Math.PI 近似的圆周率常量

public class Demo03Math {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-15));//15

        //向上取整
        System.out.println(Math.ceil(3.6));//4.0
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println("-------------------");
        //向下取整
        System.out.println(Math.floor(3.1));//3.0
        System.out.println(Math.floor(3.7));//3.0

        //四舍五入  不带小数点
        System.out.println(Math.round(3.6));//4
        System.out.println(Math.round(3.4));//3


    }
}

Math练习

计算在-10.8到2.9之间，绝对值大于6或者小于2.1的整数有多少个？

分析：
1.既然确定了范围就用for循环
2.起点位置-10.8应该转换为-10，两种办法
   2.1可以使用Math.ceil 向上取整（正方形）
   2.2强转为int舍弃小数点
3.1每一个数字都是整数，所以步进表达式应该是num++ 这样每次都是+1
4.绝对值：Mah.abs
5.一旦发现了一个数字，计数器加一

备注：如果使用Math.ceil方法，-10.8可以变成-10.0.double也是可以进行++的
 */
public class Demo04MathPractice {
    public static void main(String[] args) {
        double min = -10.8;
        double max = 5.9;
        int count = 0;
        //这样处理，变量i就是区间内的所有整数
        for (int i = (int)min; i < max; i++){
            int abs = Math.abs(i);
            if(abs > 6 || abs < 2.1){
                System.out.println(abs);
                count++;
            }


        }
        System.out.println("总共有：" + count);
    }
}

Z知行T

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习第十七章字符串/static关键字/Arrays/Math

第十七章一、字符串概述和特点概述和特点java.lang.String类代表字符串。API当中说：Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。程序冲所有双引号的字符串，都是String的对象字符串的特点：1.字符串的内容用不可变【重点】2.正是因为字符串不可改变，所以字符串是可以共享使用的3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组字符串构造方法和直接创建创建字符串常见的3+1种方式：public Strin
复制链接

扫一扫