Java_Day7接昨天ArrayList,String字符串,static关键字

如何存储基本类型数据类型:

ArrayList对象不能存储基本类型,只能存储引用类型,(整型) 不能写,但是存储基本类型我们可以选择它的包装类。

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

数值添加到集合:

生成6个1-33之间的随机数添加到集合中,并遍历一下

public static void main(String[] args) {
    //创建我们随机数对象
    Random random=new Random();
    //创建一个集合的对象
    ArrayList<Integer> arrayList=new ArrayList<>();
    //添加随机数到集合
    for (int i = 0; i <6; i++) {
        int r=random.nextInt(33)+1;
        arrayList.add(r);
    }
    for (int i = 0; i <arrayList.size() ; i++) {
        System.out.println(arrayList.get(i));
    }
}

自定义4个学生类对象添加到集合:

public static void main(String[] args) {
	//创建我们集合的对象        
	ArrayList<Student> arrayList=new ArrayList<>();
	//创建学生的对象        
    Student student1=new Student("哈登",30);        
    Student student2=new Student("威少",30);        
    Student student3=new Student("字母哥",25);        
    Student student4=new Student("肖华",50);
    //将学生的对象添加到我们的集合中      
    arrayList.add(student1);        
    arrayList.add(student2);        
    arrayList.add(student3);        
    arrayList.add(student4);
    //遍历一下我们的集合        
    for (int i = 0; i <arrayList.size(); i++) {
        Student student=arrayList.get(i);
        System.out.println(student.getName()+"‐‐‐‐‐"+student.getAge());        
	}    
}

打印集合的方法:
定义以制定的格式打印集合的方法(ArraList作为方法的参数),使用{}括起来的集合,使用@分割每一个元素,格式参数{元素@元素@元素}

public static void main(String[] args) {
    /*定义以制定的格式打印集合的方法(ArraList作为方法的参数),使用{}括起来的集合,使用@分割每一个元素,格式参数{元素@元素@元素}*/
    ArrayList<String> arrayList=new ArrayList<>();
    String str="哈登";
    String str1="威少";
    String str2="字母哥";
    arrayList.add(str);
    arrayList.add(str1);
    arrayList.add(str2);
    printArrayList(arrayList);
}
private static void printArrayList(ArrayList<String>arrayList) {
    System.out.print("{");
    //遍历我们的集合
    for (int i = 0; i < arrayList.size(); i++) {
        //获取我们的元素
        String str=arrayList.get(i);
        if(i!=(arrayList.size()1)){
            System.out.print(str+"@");
        }else{
            System.out.print(str+"}");
        }
    }
}

定义个获取所有偶数元素的集合的方法(ArrayList作为我们方法的返回值):

public static void main(String[] args) {
    //定义获取所有偶数元素的集合的方法(ArrayList作为我们方法的返回值)
    //创建随机数的对象
    Random random=new Random();
    //创建我们的ArrayList集合
    ArrayList<Integer> arrayList=new ArrayList<>();
    //添加我们的随机数到集合中
    for (int i = 0; i <30; i++) {
    int r=random.nextInt(300)+1;
    arrayList.add(r);
	}
    ArrayList<Integer> arrayList1 = getArrayList(arrayList);
    System.out.println(arrayList1);
}
public static ArrayList<Integer> getArrayList(ArrayList<Integer> arrayList){
    //再创建一个集合存放我们的偶数
    ArrayList<Integer> arrayList1=new ArrayList<>();
    //遍历我们方法传过来的集合
    for (int i = 0; i <arrayList.size() ; i++) {
        //判断为偶数,添加到我们的新创建的集合中
        Integer num=arrayList.get(i);
        if(num%2==0){
        arrayList1.add(num);
        }
    }
    return arrayList1;
}

String类

1.1 String类概述

概述

java.lang.String类代表字符串

API当中说:Java程序中的所有字符串字面值(如"abc")都作为此类的实例实现。

其实就是说:程序当中所有的双引号字符串,都是String类的对象(就算没有new,也照样是)。

String类包括用于检查序列的各个字符的方法,用于比较字符串,搜索字符串,提取字符串以及创建将所有字符翻译为大写或小写的字符串的副本。

字符串的特点
  1. 字符串的内容永不可变,字符串的值在创建后就不会发生变化。

    String s1 = "abs";
    s1 +="sd";
    System.out.println(s1);
    //内存中"abs","abssd"两个对象,刚开始s1指向的是"abs",拼接完后,s1指向了新的地址"abssd"
    
  2. 因为String对象是不可变的,所有它可以被共享。

  3. 字符串效果上相当于char[]字符数组,但是底层原理是byte[]字节数组。

    String str = "abc";
    //相当于
    char data[] = {'a','b','c'};String str = new String(data);
    

1.2 使用步骤

String在java.lang中,所有不需要导包

三种构造方法:

public String();创建一个空白字符串,不含任何内容

public String(char[] value);根据字符数组的内容,来创建对应的字符串。

public String(byte[] bytes);根据字节数组的内容,来创建对应的字符串。

public static void main(String[] args) {
    //无参构造创建一个字符对象
    String str = new String();
    //通过传字符数组构造字符串对象
    char[] charArray = {'A', 'B', 'C'};
    String str1 = new String(charArray);
    System.out.println(str1);//ABC
    //通过字节数组构造
    byte[] byteArray = {97,98,99};
    String str2 = new String(byteArray);
    System.out.println(str2);//abc
}

一种直接创建:

String str = "";

注意:直接写上双引号,就是字符串对象

字符串常量池

程序当中直接写上的双引号字符串,就在字符串常量池中

对应基本类型来说,==是进行数值的比较。

对于引用类型来说,==是进行地址值的比较。

双引号直接写的字符串在常量池当中,new的不在池当中。

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

**一、**public boolean equals(Object obj):参数可以是任何对象,只有参数是一个字符串并且内容相同才会给true,否则返回false

注意事项:

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

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

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

    “abc”.equals(str5)推荐 str5.equals(“abc”)//不推荐

**二、**public boolean equalsIgnoreCase(String str):忽略大小写,进行内容比较。

public static void main(String[] args){
    String str1 = "hello";
    String str2 = "hello";
    String str3 = "hello";
    //equals方法,比较两个字符串是否相同
    String.out.println(str1.equals(str2));
    String.out.println(str1.equals(str3));
    //equalsIgnoreCase方法,比较两个字符串是否相同,忽略大小写
    String.out.println(str1.equalsIgnoreCase(str3));
}

常用方法

判断功能的方法

public int length():获取字符串当中含有的字符个数,拿到字符串长度。

//返回字符串的长度
String.out.println(str1.length());

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

//将制定字符串拼接到该字符串的尾部
String.out.println(str1.concat("12345"));

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

//返回指定索引处的char
String.out.println(str1.charAt(2));

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

String.out.println(str1.indexOf("12"));
截取功能的方法

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

String.out.println(str1.substring(3));

public String substring(int begin, int end): 截取从begin开始,一直到end之间的字符。

String.out.println(str1.substring(3,6));

注意:[begin,end)

转换功能的方法

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

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

public String replace(CharSequence oldString,CharSequence newString);将所有出现的老字符串替换成新的字符串,返回替换之后的结果新字符串。

public static void main(String[] args){
    String s = "abcde";
    //将字符串转换成字符数组
    char[] chars = s.toCharArray();
    for(int i = 0; i < chars.length; i++){
        System.out.println(chars[i]);
    }
    byte[] bytes = s.getBytes();
    for(int i = 0; i < bytes.length; i++){
        System.out.println(bytes[i]);
    }
    //替换字符
    String str = "woaibiancheng";
    String replace = str.replace("a","A");
    System.out.println(replace);
}
分割功能的方法

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

注意事项:

split方法的参数其实是一个"正则表达式"

如果按照英文句点"." 进行切分,必须写"\\."

拼接字符串

//定义一个方法,把数组{1,2,3}按照指定格式拼接成一个字符串,格式按照如下:[word1#word2#word3]
public static void main(String[] args) {
    int[] arr = {1,2,3};
    String s = arrayToString(arr);
    System.out.println(s);
}
public static String arrayToString(int[] arr){
    String s = "[";
    //遍历数组拼接
    for (int i = 0; i < arr.length; i++) {
        if (i == arr.length-1){
            s = s.concat(arr[i]+"]");
        }else {
            s = s.concat(arr[i]+"#");
        }
    }
    return s;
}

统计字符个数

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串:");
    String input = sc.nextLine();
    int countUpper = 0;
    int countLower = 0;
    int countNumber = 0;
    int countOther = 0;
    for (int i = 0; i < input.length(); i++) {
        //获取指定索引位置的单个字符
        char ch = input.charAt(i);
        if ('A' <= ch && ch <= 'Z'){
            countUpper++;
        } else if ('a' <= ch && ch <= 'z') {
            countLower++;
        } else if ('1' <= ch && ch <= '9') {
            countNumber++;
        } else {
            countOther++;
        }
    }
    System.out.println("大写字母有:"+ countUpper);
    System.out.println("小写字母有:"+ countLower);
    System.out.println("数字有:"+ countNumber);
    System.out.println("其他字符有:"+ countOther);
}

static关键字

概述:

​ 关于static关键字的使用,它可以修饰成员变量和成员方法,被修饰的成员属于类,而不是属于单单一个类,既然static这个修饰的东西属于类,那么调用的时候,就不需要创建对象去调用。

类变量:

当static修饰成员变量时,该变量属于类,该类中每个对象都共享同一个类的变量的值,任何对象都可以更改类变量的类,但是不可以在不创建对象的情况对类变量进行操作。

类变量


public class Student {
    private String name;
    private int age;
    private int sid;

    public static int numberStudent=0;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.sid = ++numberStudent;
    }

    public String toString(){
        return "Student{" +
                "name='" + name +'\''+
                ",age=" + age +
                ",sid=" + sid +
                '}';
    }
}
public static void main(String[] args) {
    Student student=new Student("哈登",30);
    Student student1=new Student("威少",29);
    Student student2=new Student("字母哥",30);
    System.out.println(student.toString());
    System.out.println(student1.toString());
    System.out.println(student2.toString());
    //类变量的调用:类名.类变量
    System.out.println(Student.numberStudent);
}

静态方法


当static修饰成员方法时,该方法称为类方法,静态方法在申明的时候用static

//静态方法(类方法)
public static void show(){
    System.out.println("num:"+numberStudent);
}
//调用类方法:类名.类变量();
注意事项:
  1. 静态方法可以访问静态变量和静态方法
  2. 静态方法不能直接访问成员变量和成员方法,反之,成员方法能直接访问静态变量和静态方法。
  3. 静态方法不能使用this关键字

总结:静态的随着类的加载而加载,优于对象存在。静态方法只能访问静态成员。

  1. 随着类的加载而加载,且只加载一次
  2. 存储在我们的固定区域(静态区),可以直接使用类名调用
  3. 它优于对象存在,所以,所有的对象共享

静态代码块


静态代码块:定义在成员变量的位置,使用static修饰

格式:

static{}

位置:类中方法外

执行:随着类的加载而执行一次且只有一次,优于main方法和构造方法执行

public class Game{
    //类变量
    public static int number;
    public static ArrayList<String> list;
    //初始化
    static{
        //给类变量赋值
        number = 2;
        list = new ArrayList<>();
        list.add("abc");
        list.add("小白");
    }
    public static void main(String[] args) {
        System.out.println(Game.number);
    }
}

static关键字,可以修饰变量,方法和代码块,在使用过程中,其中目的就是不创造对象去直接调用。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值