java笔记

字符串的比较相关方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法:

public boolean equals(0bject obj):参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回fal se

注意事项:

1.任何对象都能用Object进行接收。

1. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。

2. 如果比较双方一个常量一个变量,推荐把常量字符串写在前面。

3. 推荐:"abc".equals(str)不推荐:str.equals("abc"")

public booLean equalsIgnoreCase(String str)。忽略大小写，进行内容比较。

public class Demo06 {
    public static void main(String[] args){
        String str1= "Hello";
        String str2= "Hello";
        char[] charsArray ={'H','e','l','l','o'};
        String str3= new String(charsArray);
        System.out.println(str1.equals(str2));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals(str1));//true
        String str4 = "hello";
        System.out.println(str1.equals(str4));
        System.out.println("===============");
        String str5 = null;
        System.out.println("abc".equals(str5));//推荐：false
        System.out.println(str5.equals("abc"));//不推荐：报错，空指针异常NullPointerException
        System.out.println("================");
        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB));//false  严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB));//true  忽略大小写
        //注意： 只有英文字母区分大小写，其它都不区分大小写
        System.out.println("abc一123".equalsIgnoreCase("abc壹23"));//false
    }
}

字符串的获取相关方法

String当中与获取相关的常用方法有:

pblic int Length():获取字符串当中含有的字符个数，拿到字符串长度。

public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串。

public char charAt(int index):获取指定索引位置的单个字符。(索引从0开始。)

public int index0f (String str)。查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

public class Demo07 {
    public static void main(String[] args) {
        //获取字符串的长度（length）
        int length = "asnakjfsakjdsdkf".length();
        System.out.println("字符串的长度:"+length);
        //拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1);//Hello
        System.out.println(str2);//World
        System.out.println(str3);//HelloWorld
        //获取指定索引位置的单个字符（charAt）
        char c = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符串是："+c);//e
        System.out.println("================");
        //查找参数字符串在本来字符串当中出现的第一次索引位置（indexOf）
        //如果根本没有，返回-1值
        String original = "HelloWordHelloWord";
        int index = original.indexOf("lo");
        System.out.println("第一次索引值是："+index);//3
        System.out.println("HelloWord".indexOf("abc"));//-1
    }
}

字符串的截取方法

1.public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串。

2.public String substring(int begin,int end)：截取从begin开始，一直到end结束，中间的字符串。

3.备注:[ begin , end)，包含左边。不包含右边。

public class Demo08 {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);//HelloWorld
        System.out.println(str2);//World
        System.out.println("==============");
​
        String str3 = str1.substring(4,7);
        System.out.println(str3);//oWo
        System.out.println("==============");
        //下面这种写法,字符串的内容仍然是没有改变的
        //下面有两个字符串:“HeLLo".""Java"
        // strA当中保存的是地址值。
        //本来地址值是HeLLo的ex666
        //后来地址值变成了Java的ex999
        String strA = "Hello";
        System.out.println(strA);//Hello
        strA="Java";
        System.out.println(strA);//Java
    }
}

字符串的转换相关方法

1.public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值。

2.public byte[ getBytes():获得当前字符串底层的字节数组。

3.public String replace(CharSequence oldString,CharSeguence newString)。

4.将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

备注:CharSequence意思就是说可以接受字符串类型。

public class Demo09 {
    public static void main(String[] args) {
        //转换成为字符数组（toCharArray）
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);//H
        System.out.println(chars.length);//5
        System.out.println("============");
        //转换成为字节数组（getBytes）
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);//97  98  99
        }
        System.out.println("=============");
        //字符串的内容替换（replace）
        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        System.out.println(str2);//H*w d* y*u d*?
    }
}

字符串的分割方法

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

注意事项：

split方法的参数其实是一个“正则表达式”,今后学习。

要注意:如果按照英文句点"."进行切分必须写"\\.”(两个反斜杠）

public class Demo10 {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);//aaa bbb ccc
        }
        System.out.println("============");
​
        String str2 = "aaa.bbb.ccc";
        String[] array2 = str2.split("\\.");
        System.out.println(array2.length);//3
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);//aaa bbb ccc
        }
​
    }
}
=========================================================================
    题目:
定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下:[wordi1#word2#word3]。
    分析:
1.首先准备一个int[]数组,内容是:1、2、3、4、5、6
2.定义—个方法,用来将数组变成字符串
三要素：
    返回值类型:String
    方法名称。fromArrayToString
    参数列表:int[]
3.格式:[ tword1eword2waword3]
用到”for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
4.调用方法,得到返回值,并打印结果字符串
    public class Demo10 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        String result = fromArrayToString(array);
        System.out.println(result);
    }
    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 Demo10 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//键盘输入字符串
        System.out.println("请输入一个字符串：");
        String Dexter = scanner.next();//获取键盘输入的一个字符串
        int countCapital = 0;//大写字母
        int countLower = 0;//小写字母
        int countNumber = 0;//数字
        int countOther = 0;//其它字符
​
        char[] chars = Dexter.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];//当前当个字符
            if('A' <= ch && ch <= 'Z'){
                countCapital++;
            }else if('a' <= ch && ch <= 'z'){
                countLower++;
            }else if ('0' <= ch && ch <= '9'){
                countNumber++;
            }else{
                countOther++;
            }
        }
        System.out.println("大写字母有："+countCapital);
        System.out.println("小写字母有："+countLower);
        System.out.println( "数字有：" + countNumber );
        System.out.println("其他有："+ countOther);
    }
}
    

static关键字

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

public class Demo10 {
    private int id;
    private String name;
    private int age;
    Static String room;
    private static int idCounter = 0;
    publuc Demo10(){
        this.id = idCounter ++;
    }
    public Demo10(String name, int age){
        this.name = name;
        this.id = idCounter;
        this.id = idCounter++;
    }
}

静态staic

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。

静态变量,类名称.静态变量

静态方法:类名称.静态方法()

注意事项:

1．静态不能直接访问非静态。

原因。因为在内存当中是【先】有的静态内容，【后】有的非静态内容。先人不知道后人,但是后人知道先人。”

2．静态方法当中不能用this。

public class MyClass {
    int num;//成员变量
    static int numStratic; //静态变量
    //成员方法
    public void methond() {
        System.out.println("这是一个成员方法");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStratic);
    }
    //静态方法
    public static void methidStatic() {
        System.out.println("这是一个静态方法");
        //静态方法可以访问静态变量
        System.out.println(numStratic);
        //静态方法不能直接访问非静态【重点】
        // System.out.println(num);  错误写法！
        //静态方法不能直接使用this关键字
        //System.out.println(this);
    }
}
================================================
    public class Demo01 {
    public static void main(String[] args) {
        MyClass obj = new MyClass();//首先创建对象
        //然后才能使用没有static关键字的内容
        obj.methond();
        //对于静态方法来说，可以通过的对象名直接调用，也可以直接通过类名称来直接调用
        obj.methidStatic();//正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methidStatic();//正确 推荐
        myMethod();
        Demo01.myMethod();//完整写法
    }
    public static void myMethod() {
        System.out.println("自己的方法");
    }
}

注意：

根据类名称访问静态成员变量的时候，全程和对象就没关系，只和类有关系

public class Student {
    static String room;
}
================================
public class Dexter {
    public static void main(String[] args) {
        //这是静态的东西，应该通过类名称进行调用
        Student.room = "510教室";
    }
}

静态代码块

//静态代码块的格式是：
//public class 类名称 {
//  static{
            //静态代码块的内容
//      }
//}
//特点： 当第一次用到本类时，静态代码块执行唯一的一次。
//静态内容总是优先于非静态，所以静态代码块比构造方法先执行
public class Student {
    static{
        System.out.println("静态代码块执行！");
    }
    public Student() {
        System.out.println("构造方法执行！");
    }
}
===========================================
public class Dexter {
    public static void main(String[] args) {
       Student one = new Student();
       Student two = new Student();
        //静态代码块执行！
        //构造方法执行！
        //构造方法执行！
    }
}