_esther_
_esther_

【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static

目录

  • 1 ArrayList 集合
    • 装箱，拆箱及包装类
  • 2 API 概述和使用
    • Scanner类
    • 匿名对象
    • Random生成随机数
  • 3 字符串
    • 字符串的3+1种构造方法
    • 字符串的常量池
      • equals和==
    • 字符串的获取相关方法
    • 字符串的截取方法
    • 字符串的转换相关方法
    • 字符串的分割方法
  • 4 静态static关键字
    • 静态static的内存图
    • 静态代码块
    • 静态方法和非静态方法的互相调用
  • ● 练习
    • 1 Scanner
    • 2 匿名对象
      • 1. 匿名对象做参数，方法用来输入和并打印输入的数
      • 2. 匿名对象做返回值，接收后调用输入内容
    • 3 Random
      • 1. 练习生成3~9之间的随机数
      • 2. 猜数字小游戏，产生一个随机数，获取输入并判断。
    • 4 对象数组
    • 5 ArrayList
      • 1. 生成6个1~33之间的随机整数，添加到集合，并遍历
      • 2. 自定义4个学生对象，添加到集合，并遍历
      • 3. 按指定格式遍历集合字符串即ArrayList
      • 4. 筛选集合中的随机数
      • 5. 创建一个ArrayList集合，不限制泛型，可以存储任何引用类型，并进行添加，删除，获取操作。打印格式：{元素1￥元素2￥元素3}
    • 6 字符串
      • 1. 定义一个数组，把数组{1,2,3}按照指定格式拼接成一个字符串 ，格式:[word1#word2#word3]
      • 2. 统计输入的字符串中各种字符的个数
      • 3. 把字符串“i. said. remember. this. moment\n in. the. back .of .my . mind\n”按照分隔符“.”分隔为字符串数组，再将字符串数组转化为char数组和byte数组。不限分隔符字符串中的字符类型。（优化：字符串和分割字符串都自己输入）
      • 4. （1）比较以下几个字符串是否是同一个String对象。（2）忽略大小写比较字符串"esEreW#212&REE"，"EserEw#212&rEe"是否相等
      • 5. （1）将 字符串“Qweken#4”与字符串“Tyuken87*90+)_”和字符串“！@3ken4s”拼接成一个字符串。
    • 7 static
      • 1. 创建一个学生类对象，要求属性：班级，学号，姓名，年龄，性别。其中班级号固定为同一个班级，学号不可随意更改，根据入学即创建学生对象的先后次序自动生成。
      • 2. 画出创建两个学生类对象过程的内存图，重点：静态成员
      • 3. 用静态代码块给学生类中的静态变量赋值
      • 4. 判断下列代码错误点分析修改，根据描述模拟情况

1 ArrayList 集合

  • 数组的长度不可以发生改变，ArrayList 集合的长度可以随意变化
  • ArrayList中指泛型
    泛型：装在集合当中的所有元素， 全都是统一的类型
    注意：泛型只能是引用类型，不能是基本类型
  • jdk 1.7开始，右侧的尖括号内部可以不写内容，但<>本身还是要写
    ArrayList list = new ArrayList<>();右侧可以不写泛型内容，但左侧一定要写，这个算是标准写法
  • 对于ArrayList直接打印的不是地址值，而是[内容]，为空则[]，一般为[元素1,元素2,元素3,元素4]
  • ArrayList打印
public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("哈哈");
        list1.add("呵呵");
        System.out.println(list1);//[哈哈, 呵呵]
        
}
  • ArrayList常用方法和遍历

public boolean add(E e)向集合中添加元素，参数类型和泛型一致；返回值boolean代表是否添加成功
public E remove(int index)根据索引删除，返回删除的元素。（索引从0开始）
public int size()获取长度，返回值是集合中包含的元素个数
public E get​(int index) 返回此列表中指定位置的元素。
list.fori 快速生成遍历循环

装箱，拆箱及包装类

  • 因为泛型只能是引用类型，不能是基本类型，因为集合存的是地址。所以基本类型对应使用“包装类”
  • 引用类型都位于java.lang包下，所以无需导包
基本类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

从JDK1.5开始，支持自动装箱，自动拆箱
自动装箱：基础类型 -> 包装类
自动拆箱：包装类 -> 基础类型

2 API 概述和使用

使用一个类：
1.导包：package语句后 import 包路径.类名称 class语句前，若要用的目标类和当前类位于同一个包下，省略导包。java.lang包下的内容不需要导包，其他的包都需要import语句。
2.创建：类名称 对象名 = new 类名称()；
3.使用：对象名.成员方法名()；
不同模块之间，不能导包或者互相使用

Scanner类

导包 import java.util.Scanner;

String next​() 查找并返回此扫描仪的下一个完整令牌。
int nextInt​() 将输入的下一个标记扫描为 int 。

public class Demo01Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个int给sc");
        int num = sc.nextInt();
        System.out.println("输入一个String给num");
        String str = sc.next();
        System.out.println("输出接收的sc,num");
        System.out.println(num + "," + str);

    }
}

练习一：输入两个int数字，并且求出和值

public class Exercise01InputSum {
    public static void main(String[] args) {
       inputSum();

    }
    public static int inputSum(){
        Scanner sc = new Scanner(System.in);
        System.out.println("输入两个整数");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();

        System.out.println("总和" + num1 + num2);
        return num1 + num2;
    }
}

练习二，输入三个数，求max先判断前2个哪个大，再把最大的跟第3个比较

public class Exercise02InputMax {
    public static void main(String[] args) {
        inputMax();
    }
    public static double inputMax(){
        System.out.println("输入3个整数");
        Scanner sc = new Scanner(System.in);
        double num1 = sc.nextDouble();
        double num2 = sc.nextDouble();
        double num3 = sc.nextDouble();
        double max = num1 < num2 ? num2 : num1;
        max = max < num3 ? num3 : max;
        System.out.println("max:" + max);
        return max;

    }

}

匿名对象

匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象

public class Demo1Anonymous {
    public static void main(String[] args) {
        Person one = new Person();
        one.name = "芭比";
        new Person().name = "肯";
        
        one.showName();//我叫null
        new Person().showName();//我叫芭比
    }
}
  • 匿名对象做参数和返回值
public class Demo2ParamReturn {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        methodParam(sc);

        //用匿名对象简化写法
        methodParam(new Scanner(System.in));
    }
    public static void methodParam(Scanner sc){
        String str = sc.next();
        System.out.println(str);
    }
}

public class Demo2ParamReturn {
    public static void main(String[] args) {
        Scanner sc = methodReturn();
        sc.next();
    }
public static Scanner methodReturn(){
//        Scanner sc = new Scanner(System.in);
//        return sc;

        //简化写法
        return new Scanner(System.in);
    }
}

Random生成随机数

【JavaSE API 】生成随机数的2种方法：Random类和Math类的Random方法

  1. 导包 import java.util.Random;
  2. 创建Random r = new Random();
  3. 使用
    获取一个随机的int数字（范围是int所有范围，有正负两种）;
    参数代表范围，左闭右开。[0,3)
int num = r.nextInt(3);

protected int next​(int bits) 生成下一个伪随机数。
int nextInt​(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。

3 字符串

在java.lang包下，所以不用导包。
程序中所有的双引号字符串，都是String类的对象（就算没有new也是）
字符串的特点：
1.内容永不可变
2.因为字符串内容不可变，所以可以共享
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

字符串的3+1种构造方法

  • 1public String();创建一个空白字符串， 不含有任何内容
  • 2public String(char[] array);根据字符数组的内容，来创建对应的字符串
  • 3public String(byte[] array);根据字节数组的内筒，来创建对应的字符串
  • 1种直接创建
    String str = "Hello";注意：直接写上双引号，就是字符串对象。只要是字符串一定是对象

字符串的常量池

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

equals和==

  • ==
    对于基本数据类型比较 内容
    对于引用类，只有是同一个对象才true（比较的是对象的内存地址）
  • equals
    只能比较引用对象，对于普通类对象，只有同为同一个对象才是true
    但对于File,String,Data和包装类，是比较内容
public class Demo2ConstantPools {
    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(str2 == str3);//false

    }
}

在这里插入图片描述
程序当中直接写上的双引号字符串，就在字符串常量池中。
即直接创建的字符串在常量池，若内容相同即为共享一个对象，3种构造方法的字符串不在常量池也不是共享，是由字符数组或字节数组在堆中转化为字节数组的地址，内容相同也不是同一个对象。

public class Demo2ConstantPools {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        
        char[] charArray = {'a', 'b', 'c'};
        String str3 = new String(charArray);

        byte[] byteArray = { 'a', 'b', 'c'};
        String str4 = new String(byteArray);

        byte[] b2 ={'a', 'b', 'c'};
        String str5 = new String(b2);

        System.out.println(str1 == str2);//true
        System.out.println(str2 == str3);//false
        System.out.println(str3 == str4);//false
        System.out.println(str4 == str5);//false
        System.out.println(str1.equals(str2));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals(str4));//true
        System.out.println(str4.equals(str5));//true
        
        System.out.println(str1.equalsIgnoreCase("ABC"));//true
    
    }
}

字符串的获取相关方法

public int length();字符个数
public String concat(String);将当前字符串和参数拼接返回
public char charAt(int index);获取指定索引位置的单个字符（从0开始）
public int indexOf(String str);查出参数字符串在本字符串中首次出现的索引位置，没有就return -1；

注意：concat方法只会把拼接的结果返回，并不改变调用方法的字符串。除非原字符串接收他的返回值

字符串的截取方法

public String substring(int index);截取从参数位置一直到字符串末尾。返回新字符串
public String substring(int begin, int end);截取从begin开始一直到end结束中间的字符串。（按照索引从0开始对应 每一个字符，截取为 [begin,end)）

字符串的转换相关方法

public char[] toCharArray();将当前字符串拆分为字符数组作为返回值
public byte[] getByte();获得当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString); 将所有出现的老字符替换成为新的字符串，返回替换后的新字符串（CharSequence简单理解为可以接受String类型）

字符串的分割方法

public String[] split(String regex);按照参数的规则将字符串切分成为若干部分
注意: 无法根据.划分做参数，split方法的参数其实是一个正则表达式，如果按照英文句“.”必须写“\\.”

split() 方法根据匹配给定的正则表达式来拆分字符串。

注意： . 、 $、 | 和 * 等转义字符，必须得加 \\。

public class Demo3StringMethod {
    public static void main(String[] args) {
        //字符串的获取相关方法-------------------------------------------------------
        String str1 = "Hi~Barbie";
        System.out.println(str1.length());
        System.out.println(str1.concat("Hi~Ken"));
        System.out.println("索引3的字符" + str1.charAt(3));
        str1 = str1.concat("bie~hello java $ rusty lake is fate 1 larua is blossom");
        System.out.println("str1 : " + str1);
        System.out.println("第一次出现bie的索引位置：" + str1.indexOf("bie"));
       
        //字符串的截取方法
        System.out.println("从4截取" + str1.substring(4));
        System.out.println("从[7,13)截取" + str1.substring(7,13));
        
        //字符串的转换相关方法
        char[] ch = str1.toCharArray();
        System.out.println("char数组：" + ch);
        System.out.println(Arrays.toString(ch));
        byte[] by = str1.getBytes();
        System.out.println("by数组：" + by + Arrays.toString(by));
        for (int i = 0; i < by.length; i++) {
            System.out.print(by[i] + ",");
        }
        System.out.println();
        String str2 = "Hoow doo yoou doo?";
        System.out.println("str2" + str2);
        System.out.println(str2.replace("oo", "*"));

        //字符串的分割方法
        String[] str3 = str1.split("a");
        System.out.println("根据a划分str1："+ str1);
        for (int i = 0; i < str3.length; i++) {
            System.out.println(str3[i]);
        }
        
 		String str3 = "ewr.e..wfs...as.a.d";
        String[] atr = str3.split("\\.");
        printArray(atr);

        String str4 = "ewr\ne.\nwfs.n.as.d";
        String[] atr2 = str4.split("\\n");
        printArray(atr2);
        
    }
}

4 静态static关键字

用于多个对象共享同一份数据的情况，例如，一个学生类Student，除过姓名成绩等不同的属性外，共同的属性应该为同一间教室，多个对象的教室属性，内容完全相同。无需作为对象成员变量，每次赋不同的值。只需赋值一次，多个对象共享即可。
一旦用了static关键字，那么这样的内容不在属于对象自己，而是属于类的，所以凡是本类的对象，都共享一份static变量或方法。

例如：定义学生类中学号为static，作用：每new一个学生对象，学号都自增统计学生数量

public class DemoStatic {
    public static void main(String[] args) {
        Student stu1 = new Student("barbie",true,18);
        Student stu2 = new Student();
        Student stu3 = new Student("奥罗拉",true,16);
        Student stu4 = new Student("菲利普",false, 17);
        stu3.showInfo();
        stu2.showInfo();
        stu4.showInfo();
    }
}


学生学号：3 姓名：奥罗拉 是否女孩：true 年龄：16
学生学号：2 姓名：null 是否女孩：false 年龄：0
学生学号：4 姓名：菲利普 是否女孩：false 年龄：17

静态方法不属于对象，而是属于类。如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用他。

MyClass obj = new MyClass();
        obj.method();

        obj.methodStatic();//不推荐，会误以为是普通成员方法。
        MyClass.methodStatic();

对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
不推荐用对象调用静态方法，因为会误以为是普通成员方法，且编译后也会被javac翻译成为类名称,.静态方法名
有static，都推荐使用类名称进行调用。
对于本类当中的静态方法，可以省略类名称直接调用。
注意：
1.静态不能直接访问非静态
2. 静态方法当中不能用this
因为在内存当中是先有得静态内容，后有的非静态内容。
this代表当前对象，通过谁调用的方法 ，谁就是当前对象。但静态方法不用对象

静态static的内存图

静态方法就算写为对象.方法，对象.属性。编译期间也会翻译为类.方法或类.属性，然后去方法区找。跟对象无关

public class Student {
    //为什么定义两个，因为id属于学生的属性，属于对象，每个对象不一样。但idCount属于属于类
    //每次new该类对象才自增，不保存加过的数
    private static int idCount = 0;
    private int id = 0;
    static String room = "一年级一班";
    String name;
    boolean girl;
    int age;

    public Student(String name, boolean girl, int age) {
        this.id = ++idCount;
        this.name = name;
        this.girl = girl;
        this.age = age;
    }
    public Student(){
        this.id = ++idCount;
    }
    public void showInfo(){
        System.out.println("学生学号：" + this.id + " 姓名：" + this.name + " 是否女孩：" + this.girl + " 年龄：" + this.age);
    }

    public static void setRoom(String room) {
        Student.room = room;
    }

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

    public void setGirl(boolean girl) {
        this.girl = girl;
    }

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

    public static int getIdCount() {
        return idCount;
    }

    public int getId() {
        return id;
    }

    public static String getRoom() {
        return room;
    }

    public String getName() {
        return name;
    }

    public boolean isGirl() {
        return girl;
    }

    public int getAge() {
        return age;
    }

}

public class Demo02Static {
    public static void main(String[] args) {
        Student.room = "大一一班";

        Student one = new Student("小刘", false, 20);
        System.out.println("one的姓名：" + one.getName());
        System.out.println("one的教室：" + Student.getRoom());
        System.out.println("one的年龄：" + one.getAge());
        System.out.println("one的学号：" + one.getId());
        System.out.println("============================");
        Student two = new Student("小李", true, 12);
        System.out.println("two的姓名：" + two.getName());
        System.out.println("two的教室：" + Student.getRoom());
        System.out.println("two的年龄：" + two.getAge());
        System.out.println("two的学号：" + two.getId());

        System.out.println("学生人数：" + Student.getIdCount());

    }

}

在这里插入图片描述
注意：根据类名称访问静态成员变量的时候，全程和对象没关系，只和类有关

静态代码块

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行
格式：

public class 类名称{
	static{
  		//静态代码块的内容
	}
}

静态代码块的典型用途：用来一次性地对静态成员变量进行赋值

静态方法和非静态方法的互相调用

【JavaSE语法】类之间方法的调用（静态方法与非静态方法间的互相调用）

非静态方法调用内部类方法：一律直接调，方法名(参数)
非静态方法调用外部类方法：静态方法用类名.方法名。非静态方法用对象名.方法名(参数)。
静态方法调用静态方法：内部类的方法直接调方法名(参数)，同包外部类的方法用类名.方法名(参数)。
静态方法调用非静态方法：一律用对象.方法名(参数)。

● 练习

1 Scanner

  1. 输入四行话，并输出合并后的句子
    A:
		Scanner sc = new Scanner(System.in);
        String str1 = sc.next();
        str1 += sc.next();
        str1 += sc.next();
        str1 += sc.next();
        System.out.println(str1);
  1. 输入三个数，求max。先判断前两个哪个大，再把最大的跟第三个比较
    A:
 		//输入三个int数，输出最大的
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        int num3 = sc.nextInt();
        num1 = num1 > num2 ? num1 : num2;
        num3 = num1 > num3 ? num1 : num3;
        System.out.println(num3);

2 匿名对象

1. 匿名对象做参数，方法用来输入和并打印输入的数

public static void method1(Scanner sc){
        System.out.println("输入几个整数，判断最小值");

        int num = sc.nextInt();
        int max = num;
        for(int i = 0; i < 5; i++){
            if(sc.hasNextInt()){
                num = sc.nextInt();
                max = num < max? num: max;
            }
            else{
                String str = sc.next();//把错误数据先读取掉，免得后续又读到
                System.out.println("输入的不是整数，重新输");
                
            }
        }
        System.out.println(max);

    }

	public static void main(String[] args) {
        //1.匿名对象做参数，方法用来输入和并打印输入的数
        method1(new Scanner(System.in));
    }

【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第1张图片

2. 匿名对象做返回值，接收后调用输入内容

	public static Scanner method2(){
        Scanner sc = new Scanner(System.in);
        return sc;
    }

 	public static void main(String[] args) {
        Scanner sc = method2();
        System.out.println(sc.next());
    }

3 Random

1. 练习生成3~9之间的随机数

A:用Math和Random类两种生成随机数

 //想生成，[3,9]的随机数
        for (int i = 0; i < 10; i++) {
            Random r1 = new Random();
            System.out.print("Random:" + (r1.nextInt(7) + 3));

            System.out.print(" Math:" + (int)(3 + Math.random() * 7) );
            System.out.println();
        }

2. 猜数字小游戏，产生一个随机数，获取输入并判断。

A:

boolean flag = true;
        System.out.println("请输入猜的数字，范围1~100");
        int tmp = new Random().nextInt(100) + 1;
        int time = 0;
        while(flag){
            time++;
            Scanner sc = new Scanner(System.in);
            if(sc.hasNextInt()){
                int num = sc.nextInt();
                if(num > tmp){
                    System.out.println("猜大了");
                }else if(num < tmp){
                    System.out.println("猜小了");
                }else{
                    System.out.println("恭喜你猜对了！本轮用了" + time + "次");
                }
            }else{
                System.out.println("输错了，不是整数，重新输");
            }

4 对象数组

要求定义一个数组，用来存3个Person对象
默认值为null,分别创建Person对象入数组
A：

	public static void main(String args){
		Person[] arr1 = new Person[3];
        Person p1 = new Person("barbie", "女", 100);
        Person p2 = new Person();
        Person p3 = new Person("ken", "男", 30);

        arr1[0] = p1;
        arr1[1] = p2;
        arr1[2] = p3;

        System.out.println(arr1[0].getName());
        System.out.println(arr1[2].getAge());
  }

5 ArrayList

复习ArrayList,按照添加顺序的顺序存储，可以重复存储，有索引从0开始
标准定义： ArrayList list = new ArrayList<>();
打印：直接打印，出现的是内容，而不是地址值。数组和对象直接打印才是地址值

1. 生成6个1~33之间的随机整数，添加到集合，并遍历

public class Exercise1List {
    public static void main(String[] args) {
        for (int n = 0; n < 1000; n++) {//测试100次
            Random r = new Random();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < 6; i++) {
                int num = r.nextInt(33) + 1;
                list.add(num);
                
            }
            System.out.println(list);

        }
    }
}

2. 自定义4个学生对象，添加到集合，并遍历

public class Exercise2List {
    public static void main(String[] args) {
        Student stu1 = new Student("barbie",true,"研二");
        Student stu2 = new Student("ken",false,"大一");
        Student stu3 = new Student("小明",true,"一年级");
        Student stu4 = new Student("小李",false,"幼儿园");

        ArrayList<Student> list = new ArrayList<>();
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).name);
        }
    }

3. 按指定格式遍历集合字符串即ArrayList

  • 定义以指定格式打印集合的方法(ArrayList类型作为参数）使用{}扩起集合，使用@分隔元素，
  • 格式参照{元素1@元素2@元素3@元素4}
public class Exercise03List {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("一");
        list.add("二");
        list.add("三");

        printArray(list);

    }
    public static void printArray(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            if(i == list.size() - 1){
                System.out.print(list.get(i));
            }else{
                System.out.print(list.get(i) + "@");
            }
        }
        System.out.println("}");
    }
}

4. 筛选集合中的随机数

用一个大集合存入20个随机数字，然后筛选其中的偶数，放到小集合当中。要求使用自定义的方法来实现筛选，集合当返回值

public class Exercise04List {
    public static void main(String[] args) {
        System.out.println(evenNumber(20));
    }

    //参数：确定传入大集合的随机数个数
    public static ArrayList<Integer> evenNumber(int size){
        ArrayList<Integer> maxList = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            Random r = new Random();
            maxList.add(r.nextInt());
        }
        System.out.println(maxList);

        ArrayList<Integer> minList = new ArrayList<>();
        for (int i = 0; i < maxList.size(); i++) {
            if(maxList.get(i) % 2 == 0){
                minList.add(maxList.get(i));
            }
        }
        return minList;
    }

}

5. 创建一个ArrayList集合，不限制泛型，可以存储任何引用类型，并进行添加，删除，获取操作。打印格式：{元素1￥元素2￥元素3}

A: 无泛型的ArrayList定义方式，List list = new ArrayList();可以添加任意类型的元素，包括自定义类

public class Code01 {
    public static void printArray(List list){
        System.out.printf("{");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
            if(i != list.size() - 1){
                System.out.print('￥');
            }
        }
        System.out.printf("}");
    }
    public static void main(String[] args) {
        List list1 = new ArrayList();
        list1.add(23);
        list1.add("erxd");
        list1.add(new Person("人1", "女", 30));
        list1.add('4');
        Person p1 = new Person("人2", "男", 18);
        list1.add(p1);

        System.out.println(list1.get(1));
        printArray(list1);
        list1.remove(4);
        printArray(list1);
    }
}

6 字符串

  • 字符串在java.lang包下，所以不用导入

  • 程序当中所有的双引号字符串，都是String类的对象。（就算没有new String 也照样是）

  • 字符串的特点

    • 字符串的内容永不可变
    • 因为字符串不可改变，所以字符串是可以共享的
    • 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

  • 字符串的构造方法3+1种（3种构造方法，1种直接创建）

    • public String(); 创建一个空白字符串，不含有任何内容
    • public String(char[] array);根据字符数组的内容，来创建对应的字符串
    • public String(byte[] array);根据字节数组的内容，来创建对应的字符串
    • 1种直接创建：String str = "Hello";直接写上双引号，就是字符串对象，只要是字符串对象准是对象

  • 注意：直接创建的字符串在常量池，若内容相同即为共享一个对象。3种构造方法的字符串不在常量池也不是共享，是由字符数组或字节数组在堆中转化为字节数组的地址，内容相同也不是同一个对象。

  • 字符串的常用方法

    • int length();获取字符串长度，即几个字符就多长
    • String concat(String str);将原字符串和参数字符串拼接并返回，注意：并不会改变原字符串和参数字符串
    • char charAt(int index);根据索引找到字符串对应位置的字符返回，索引从0 开始算
    • int indexOf(String str);根据参数字符串，找到原字符串中第一次出现参数的位置索引并返回
    • String substring( int index);截取字符串的index位置一直到字符串末尾，并返回这个新字符串
    • String substring(int begin, int end);截取 [begin,end) 部分的字符串并返回这个新字符串
    • char[] toCharArray();把原字符串转化为char数组并返回
    • byte[] getBytes();转化为byte数组并返回
    • String replace(CharSequence oldString, CharSequence newString);把字符串中的固定字符串转化为新字符串，CharSequence简单理解可接受String类型
    • String[] split(String regex);根据参数划分字符串为字符串数组并返回，不可用.划分，用.的话就用转义字符\\.

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

A:
利用任何数据类型与String类+后，都会自动转化为字符串并拼接的特点。依次遍历数组内容，并通过+=将数组元素一个个连同分隔符#加到字符串中，并返回即可。

public class Class01<T>{
    //定义一个数组，把数组{1,2,3}按照指定格式拼接成一个字符串,格式:[word1#word2#word3]
    public static<T> String splicing(T[] arr){
        String str1 = "[";

        for (int i = 0; i < arr.length; i++) {
            str1 += arr[i];//任何数据类型和字符串+,就会自动拼接
            if(i == arr.length - 1){
                continue;
            }
            str1 += '#';
        }
        str1 += ']';
        return str1;
    }

}


public static void main(String[] args) {
        //测试Class01
        Integer[] arr1 = {12, 23, 123, 564, 345, 23};
        String atr1 = splicing(arr1);
        System.out.println(atr1);

        String[] arr2 = {"!@", "#$", "%^&"};
        Character[] arr3 = {48, '#', '*', 97, 65};
        System.out.println(splicing(arr2));
        System.out.println(splicing(arr3));

    }

结果

[12#23#123#564#345#23]
[!@##$#%^&]
[0###*#a#A]

2. 统计输入的字符串中各种字符的个数

键盘输入一个字符串，并且统计其中各种字符出现的次数。种类有：大写字母、小写字母、数字、其他。
A:
将字符串转化为字符数组用char[] toCharArray(); 再根据字符串的长度int length();遍历字符串进行统计，或者转化后的字符数组长度也可以。

  • Scanner中next()和nextLine()的区别
    next() 与 nextLine() 区别
next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。
nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

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

    //数字0,48~57;a,97~122;A,65~90;
    public int[] countChar(String str){
        char[] ch = str.toCharArray();
        int[] count= new int[4];//三个元素分别代表，数字字符个数，小写字母个数，大写字母个数，其他字母个数
        for (int i = 0; i < str.length(); i++) {
            if(ch[i] >= 48 && ch[i] <= 57){
                count[0]++;
            }else if(ch[i] >= 97 && ch[i] <= 122){
                count[1]++;
            }else if(ch[i] >= 65 && ch[i] <= 90){
                count[2]++;
            }else{
                count[3]++;
            }
        }

        return count;
    }

}

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一串随机的字符，回车结束：");
        String str = sc.nextLine();
        int[] arr = new Class01().countChar(str);
        //int[] arr = new Class01().countChar("1234%^ttehd#$234@#3%6742EWgfvQ");
        //printArray(arr);
        System.out.println("这串字符中，数字字符个数：" + arr[0]
        + "，小写字母个数：" + arr[1] + "，大写字母个数：" + arr[2] + ",其他字符个数：" + arr[3]);
    }

【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第2张图片

3. 把字符串“i. said. remember. this. moment\n in. the. back .of .my . mind\n”按照分隔符“.”分隔为字符串数组，再将字符串数组转化为char数组和byte数组。不限分隔符字符串中的字符类型。（优化：字符串和分割字符串都自己输入）

A: 用String[] split(String regex); 根据参数分割字符串并返回分割后的字符串数组，用+把字符串数组拼接为字符串，用char[] toCharArray();把字符串转化为字符数组，用byte[] getBytes();把字符串转化为字节数组

  • 其中，split方法的参数其实是一个“正则表达式”，如果按英文句点.做参数划分必须写\\.，两个反斜杠。所以再用String replace（String old, String new）在分割之前就把.替换成\\.。包括\n，要匹配，只能用\\n做分隔符，代表\n
		String str3 = "ewr.e..wfs...as.a.d";
        String[] atr = str3.split("\\.");
        printArray(atr);

        String str4 = "ewr\ne.\nwfs.n.as.d";
        String[] atr2 = str4.split("\\n");
        printArray(atr2);

[ewr,e,,wfs,,,as,a,d]
[ewr,e.,wfs.n.as.d]

public class Class02 {
    // 把字符串按照分隔符“.”分隔为字符串数组，再将字符串数组转化为char数组和byte数组。
    //把字符串“i. said. remember. this. moment\n in. the. back .of .my . mind\n”

    public String[] conversion(String str, String sep){
        if(sep.indexOf(".") != -1){//说明有要替换为转义字符\\.
            sep = sep.replace(".", "\\.");
        }
        if(sep.indexOf("\n") != -1){//说明有要替换为转义字符\\.
            sep = sep.replace("\n", "\\n");
        }
        return str.split(sep);
    }
    public char[] toChar(String[] str){
        //把字符串数组拼接成一个字符串，再用方法
        String str2 = new String();
        for (int i = 0; i < str.length; i++) {
            str2 += str[i];
        }
        return str2.toCharArray();
    }
    public byte[] toByte(String[] str){
        String str2 = new String();
        for (int i = 0; i < str.length; i++) {
            str2 += str[i];
        }
        return str2.getBytes();

    }
}


	public static void main(String[] args) {
		/*测试Class02*/
        Class02 c2 = new Class02();
        Scanner sc2 = new Scanner(System.in);
        System.out.println("输入要用来分割的字符串，回车结束:");
        String str1 = sc2.nextLine();
        System.out.println("输入作为分隔符的字符串，回车结束：");
        String str2 = sc2.nextLine();

        String[] strArr1 = c2.conversion(str1, str2);
        System.out.println("分割后的字符串数组：");
        printArray(strArr1);
        System.out.println("转为字符数组后打印如下：");
        printArray(c2.toChar(strArr1));
        System.out.println("转为字节数组后打印如下：");
        printArray(c2.toByte(strArr1));
   }

【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第3张图片
【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第4张图片
失败尝试：\n还是不能做分隔符，直接使用在split中可以，要读取字符串中的\n符号不行
【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第5张图片

4. （1）比较以下几个字符串是否是同一个String对象。（2）忽略大小写比较字符串"esEreW#212&REE"，"EserEw#212&rEe"是否相等

 		String str1 = new String("abc");
        char[] ch1 = {'a', 'b', 99};
        String str2 = new String(ch1);
        String str22 = new String(ch1);

        byte[] by1 = {97, 98, 99};
        String str3 = new String(by1);

        String str4 = "abc";
        String str5 = "ab" + "c";
        String str6 = "a".concat("bc");

A（1）: 3+1种字符串创建方式的字符串，且内容相同。
注意：

  • 创建字符串的方法中，只有1种直接创建的字符串存在堆中的常量池，所以内容相同就是同一个对象同一个地址，包括+号拼接的字符串。
  • 其他创建方法，包括concat拼接的字符串，生成的字符串都在堆中单独存在，哪怕用的是同一个数组创建的字符串，底层也是new一个新的对象，指向参数的数组。所以内容相同，地址也绝对不同，也不是同一个对象
    【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第6张图片
		System.out.println(str1 == str2);//false
        System.out.println(str1 == str3);
        System.out.println(str1 == str4);
        System.out.println(str1 == str5);
        System.out.println(str1 == str6);
        ……

结果：用== 比较的是引用类型的地址，只有str4 == str5是true，其他全部不等为false
A(2):

 System.out.println("esEreW#212&REE".equalsIgnoreCase("EserEw#212&rEe"));//true

5. （1）将 字符串“Qweken#4”与字符串“Tyuken87*90+)_”和字符串“！@3ken4s”拼接成一个字符串。

（2）在字符串“23ken4#￥ken8dczxken”字符串中，返回字符串“ken”第一次出现的位置。
（3）再把其中的字符串“ken”统一换为“barbie”。
（4）返回4,8，12索引位置的字符。
（5）截取位置12到结尾的字符串返回，截取[4,8]这一段位置的字符串返回打印。

A: 注意，这些字符串相关方法，只会返回处理的结果，并不会改变原字符串，除非用原字符串名重新接收返回值。
A(1):

String str1 = "Qweken#4".concat("Tyuken87*90+)_").concat("！@3ken4s");
System.out.println(str1);

A(2):

String str1 = "23ken4#￥ken8dczxken";
        System.out.println("字符串：" + str1 + "，ken字符串第一次出现的索引是：");
        System.out.println(str1.indexOf("ken"));

A(3):

 		System.out.println("字符串：" + str1 + "中的ken换为barbie以后：");
        String str2 = str1.replace("ken", "barbie");
        System.out.println(str2);

A(4):

System.out.println("字符串str1：" + str1 + "索引4,8,12的字符分别是：");
        System.out.println(str1.charAt(4));
        System.out.println(str1.charAt(8));
        System.out.println(str1.charAt(12));

A(5):

 		System.out.println("截取字符串" + str1 + "索引12到结尾的部分：");
        System.out.println(str1.substring(12));
        System.out.println("截取字符串" + str1 + "索引[4,8]的部分：");
        System.out.println(str1.substring(4,9));

        System.out.println("再次输出str1,可以发现与最开始并没有变");
        System.out.println(str1);

7 static

1. 创建一个学生类对象，要求属性：班级，学号，姓名，年龄，性别。其中班级号固定为同一个班级，学号不可随意更改，根据入学即创建学生对象的先后次序自动生成。

A:

public class Student {
  
    private static String room;
    private static int idCount;//用来自增给id赋值，意为学生人数
    private int id;
    private String name;
    private boolean sex;
    private int age;

    public Student(String name, boolean sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.id = ++idCount;
    }
    public Student(){
        this.id = ++idCount;
    }

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

    public void setSex(boolean sex) {
        this.sex = sex;
    }

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

    public String getName() {
        return name;
    }

    public static int getIdCount() {
        return idCount;
    }


    public boolean isSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }

    public void showInfo(){
        System.out.println("班级：" + this.room + "学号：" + id +
                "姓名：" + this.name + "性别：" + sex + "年龄:" + age);
    }

 public static void main(String[] args) {
        Student stu1 = new Student("张三", false, 45);
        Student stu2 = new Student("灵儿", true, 16);
        Student stu3 = new Student();

        stu1.showInfo();
        stu2.showInfo();
        stu3.showInfo();
 }

班级：null学号：1姓名：张三性别：false年龄:45
班级：null学号：2姓名：灵儿性别：true年龄:16
班级：null学号：3姓名：null性别：false年龄:0

2. 画出创建两个学生类对象过程的内存图，重点：静态成员

【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第7张图片
赋的值也在静态区，静态成员就存储在静态区

3. 用静态代码块给学生类中的静态变量赋值

A: 在Student类中加上这段，注意。静态代码块只在类第一次被使用时执行唯一的一次，所以inCount 初始化0并不会影响后续idCount++。

static{
        room = "九年级五班";
        idCount = 0;
}

班级：九年级五班学号：1姓名：张三性别：false年龄:45
班级：九年级五班学号：2姓名：灵儿性别：true年龄:16
班级：九年级五班学号：3姓名：null性别：false年龄:0

4. 判断下列代码错误点分析修改，根据描述模拟情况

（1）

private static String room;
    private static int idCount;//用来自增给id赋值，意为学生人数
    private int id;
    private String name;
    private boolean sex;
    private int age;
    public void showInfo(){
        System.out.println("班级：" + this.room + "学号：" + id +
                "姓名：" + this.name + "性别：" + this.sex + "年龄:" + age);
    }
    public static void stMethod1(){
        showInfo();
        System.out.println(this.sex);
    }

（2）写静态方法调用非静态方法，静态方法调用静态方法的区别。包括同包不同类即外部类和类内部两种情况。

（3）写非静态方法调用非静态方法，非静态方法调用静态方法。内外部类方法调用的区别

（4）因为静态导入的情况下，可以在本类的静态方法中，直接调用导入类的静态成员而不是用类名调用，那如果内部类与外部类的静态成员同名，并静态导入。直接调是识别哪一个成员？

A（1）：

  • 静态方法不可以直接访问非静态，因为内存中现有静态后有非静态。
  • 不可以在静态方法中用this，因为静态成员是属于类的，没有对象，就没有this可用。
	private static String room;
    private static int idCount;//用来自增给id赋值，意为学生人数
    private int id;
    private String name;
    private boolean sex;
    private int age;
    public void showInfo(){
        System.out.println("班级：" + this.room + "学号：" + id +
                "姓名：" + this.name + "性别：" + this.sex + "年龄:" + age);
                // ● this.room没错，只是多余。room是静态变量，就算在非静态方法中可以使用this调用非静态，也无效，会编译为类名.静态，若是类内部的就是直接静态名
    }
	public static void stMethod1(){
		//showInfo(); ● 错误点，静态方法不可以直接访问非静态，因为内存中现有静态后有非静态。
        //System.out.println(this.sex); ● 错误点，静态方法与对象无关，不可以使用this
        new Student().showInfo();//静态方法中通过new对象访问非静态方法和变量
        System.out.println(idCount);//本类的静态成员可以直接访问
        System.out.println(new Student().sex);
    }

A(2):

总结：

  • 静态方法中
    调用本类的静态方法/变量，直接方法名(); ， 变量名
    调用外部类的静态方法/变量，类名.方法名(); , 类名.变量名
    调用非静态方法/变量，无论类内部或类外部统一 类对应的对象名.方法名(); , 对象名.变量名

重点看Class01的静态方法1，stc1Method1

import static code01.Class02.*;
	public class Class01 {
     public static void stc1Method1(){
        System.out.println("------Class01的静态方法1 成功执行------");

        Class01 c1 = new Class01();
        Class02 c2 = new Class02();
        num1 = 10;// ● 内部静态直接使用
        c1.num2 = 20;//  ● 哪怕是本类的变量，但只要是非静态在静态方法中调用就必须用对象名才可以
        Class02.num3 = 30;// ● 外部静态，用外部类名
        c2.num4 = 40;// ● 外部非静态，用外部类的对象名

        System.out.println("Class01的num1,num2:" + num1 + ", " + c1.num2);
        System.out.println("Class02的num3,num4:" + Class02.num3 + "," + c2.num4);

        stc1Method2();//同上，内部静态
        c1.c1Method1();//同上，内部非静态

        Class02.stc2Method1();//同上，外部类静态
        stc2Method2();//因为这里静态导入了外部类，所以也可以直接方法名使用外部静态。
        c2.c2Method1();//同上，外部非静态
        System.out.println("-----------------------");

    }
    public static void stc1Method2(){
        System.out.println("Class01的静态方法2 成功执行");

    }
    public void c1Method1(){
        System.out.println("Class01的方法1 成功执行");

    }
    public void c1Method2(){
        System.out.println("Class01的方法2 成功执行");

    }
}

public class Class02 {
    public static void stc2Method1(){
        System.out.println("Class02的静态方法1 成功执行");
    }
    public static void  stc2Method2(){
        System.out.println("Class02的静态方法2 成功执行");

    }
    public void c2Method1(){
        System.out.println("Class02的方法1 成功执行");

    }
    public void c2Method2(){
        System.out.println("Class02的方法2 成功执行");

    }
}


 public static void main(String[] args) {
        Class01.stc1Method1();
    }

A(3):
总结：

  • 非静态方法中
    调用本类的方法/变量，无论静态或非静态，直接方法名(); ， 变量名
    调用外部类的静态方法/变量，类名.方法名(); , 类名.变量名
    调用外部类的非静态方法/变量，类对应的对象名.方法名(); , 对象名.变量名

根据前一个问题的代码，只修改Class02的c2Method1方法内容

 public void c2Method1(){
        System.out.println("--------Class02的方法1 成功执行--------");
        Class01 c1 = new Class01();

        Class01.num1 = 50;// ● 外部静态用类名
        c1.num2 = 60;//  ● 外部非静态用对象名

        num3 = 70;// ● 内部静态或非静态都是直接调用
        num4 = 80;
        this.num3 = 90;// ● 当然非要写类名或者对象名调用也可以，只是多余，没必要
        Class02.num3 = 100;
        this.num4 = 110;

        System.out.println("Class01的num1,num2:" + Class01.num1 + ", " + c1.num2);
        System.out.println("Class02的num3,num4:" + num3 + "," + num4);

        stc2Method2();//同上，内部静态
        c2Method2();//同上，内部非静态,只要是内部统统直接调

        Class01.stc1Method2();//同上，外部类静态
        c1.c1Method2();//同上，外部非静态
        System.out.println("-------------------------------------");

    }

A(4):
假设Class03和Class04两个类中存在静态的同名变量和方法

package code01;
public class Class03 {
    int num1;
    static int num2;
    static void stMethod(){
        Class03 c3 = new Class03();
        c3.num1 = 10;
        num2 = 20;
        System.out.println("num1:" + c3.num1 + "num2:" + num2);
        System.out.println("Class03的静态方法执行");
    }
}

package code01;
import static code01.Class03.*;
public class Class04 {
    int num1;
    static int num2;
    static void stMethod(){
        Class04 c4 = new Class04();
        c4.num1 = 30;
        num2 = 40;
        System.out.println("num1:" + c4.num1 + "num2:" + num2);
        System.out.println("Class04的静态方法执行");
    }

    public static void main(String[] args) {
        stMethod();
    }
}

num1:30num2:40
Class04的静态方法执行

改变Class04中重名静态成员的名称，其他不变。之前的直接调用是调用本类的静态成员，就变成了调用外部类的静态成员。

  • 说明静态导入的情况下，外部类的静态成员与本类的静态成员名称相同则导入失效，就近原则，优先默认为本类的静态成员。只有当不同名时，静态导入后，直接调用外部类静态成员可以调成功
package code01;
public class Class03 {
    int num1;
    static int num2;
    static void stMethod(){
        Class03 c3 = new Class03();
        c3.num1 = 10;
        num2 = 20;
        System.out.println("num1:" + c3.num1 + "num2:" + num2);
        System.out.println("Class03的静态方法执行");
    }
}


package code01;
import static code01.Class03.*;
public class Class04 {
    int num1;
    static int num3;//  ● 只改变了这两个名称
    static void stMethod1(){// ● 
        Class04 c4 = new Class04();
        c4.num1 = 30;
        num2 = 40;
        System.out.println("num1:" + c4.num1 + "num2:" + num2);
        System.out.println("Class04的静态方法执行");
    }

    public static void main(String[] args) {
        stMethod();
    }
}


num1:10num2:20
Class03的静态方法执行

【JavaSE】P114~P147 ArrayList集合，Scanner类，Random,字符串及相关常用方法，静态static_第8张图片

你可能感兴趣的:(Java语法,java,开发语言)

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
  • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
  • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
  • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
  • java实体中返回前端的double类型四舍五入（格式化） 婲落ヽ紅顏誶 java
    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • Java学习笔记01 .wsy. 日常java学习笔记
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • Azkaban各种类型的Job编写 __元昊__
    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
  • java基础相关面试题详细总结 。。。。。96 java开发语言
    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
  • javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记javascript开发语言ecmascript
    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript开发语言ecmascript
    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
  • JSON与AJAX：网页交互的利器 入冉心 jsonajax前端
    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
  • 程序员开发技术整理 laizhixue 学习前端框架
    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
  • javascript的数据类型及转换 田小田txt
    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
  • java线程之Lock的使用 dimdark
    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解 爱跑步的程序员~ 刷题蓝桥杯省赛
    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
  • Java学习笔记04：Java_数组 JasonYangQ Javajava
    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
  • 【设计模式】Java 设计模式之桥接模式（Bridge） 新手村长 Java设计模式设计模式java桥接模式
    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java 计算机程序老哥
    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
  • java selenium 元素点击不了 马达马达达 selenium测试工具
    最近做了一个页面爬取，很有意思被机缘巧合下解决了。这个元素很奇怪，用xpath可以定位元素，但是就是click()不了。试过了网上搜的一些办法：//尝试一WebElementa_tag=driver.findElement(By.xpath("xxx"));a_tag.click();//点击不了，卡住//尝试二WebDriverWaitwait=newWebDriverWait(driver,1
  • 【Java初阶（三）】方法的使用 PU-YUHAN Java从入门到精通java开发语言递归方法
    ❣博主主页:33的博客❣▶文章专栏分类:Java从入门到精通◀我的代码仓库:33的代码仓库目录1.前言2.方法的概念2.1方法定义2.2实参和形参的关系3.方法的重载3.1方法重载的概念4.递归4.1递归的概念4.2递归过程分析4.3递归练习5.总结1.前言在前面的学习中，我们已经学习了Java的部分知识，包括数据类型与变量，运算符，分支与循环以及输入和输出这些基础知识，我们继续对Java的学习进
  • 解析XML文件的几种方式？ 人生在勤，不索何获 xml
    在Java中解析XML文件可以通过多种方式完成，其中最常用的有DOM（DocumentObjectModel）、SAX（SimpleAPIforXML）和StAX（StreamingAPIforXML）。每种方式有其特点和适用场景。1.DOM解析DOM解析是一种将整个XML文档加载到内存中，构造成一个树形结构，然后你可以很方便地访问任何数据节点的方法。这种方法适用于需要频繁读写操作的场景。impo
  • javascript实现SM2加密解密 人生在勤，不索何获 javascript前端jquery
    前提JavaWeb环境前端代码window.sm2=function(t){functioni(e){if(r[e])returnr[e].exports;varn=r[e]={i:e,l:!1,exports:{}};returnt[e].call(n.exports,n,n.exports,i),n.l=!0,n.exports}varr={};returni.m=t,i.c=r,i.d=fu
  • Vue：为什么要使用v-cloak 刻刻帝的海角 vue.js前端javascript
    Vue.js是一种流行的JavaScript框架，它使我们能够构建交互性强大的用户界面。在Vue.js中，v-cloak是一个指令，用于解决在页面加载时出现的闪烁问题。本文将介绍如何使用v-cloak及代码来优化Vue.js应用程序的渲染效果。引言当我们使用Vue.js构建应用程序时，有时会遇到一个问题：在页面加载时，由于Vue.js需要一定的时间来解析和渲染模板，会导致页面上显示出未经处理的Mu
  • Github 2024-03-26 开源项目日报 Top10 老孙正经胡说 github开源Github趋势分析开源项目PythonGolang
    根据GithubTrendings的统计，今日(2024-03-26统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Python项目3TypeScript项目3JupyterNotebook项目2C++项目1GDScript项目1Lua项目1Solidity项目1OpenInterpreter:本地代码运行和自然语言界面创建周期：254天开发语言：Python协议
  • log4j对象改变日志级别 3213213333332132 javalog4jlevellog4j对象名称日志级别
    log4j对象改变日志级别可批量的改变所有级别，或是根据条件改变日志级别。 log4j配置文件： log4j.rootLogger=ERROR,FILE,CONSOLE,EXECPTION #log4j.appender.FILE=org.apache.log4j.RollingFileAppender log4j.appender.FILE=org.apache.l
  • elk+redis 搭建nginx日志分析平台 ronin47 elasticsearchkibanalogstash
                 elk+redis 搭建nginx日志分析平台 logstash,elasticsearch,kibana 怎么进行nginx的日志分析呢？首先，架构方面，nginx是有日志文件的，它的每个请求的状态等都有日志文件进行记录。其次，需要有个队 列，redis的l
  • Yii2设置时区 dcj3sjt126com PHPtimezoneyii2
    时区这东西，在开发的时候，你说重要吧，也还好，毕竟没它也能正常运行，你说不重要吧，那就纠结了。特别是linux系统，都TMD差上几小时，你能不痛苦吗？win还好一点。有一些常规方法，是大家目前都在采用的1、php.ini中的设置，这个就不谈了，2、程序中公用文件里设置，date_default_timezone_set一下时区3、或者。。。自己写时间处理函数，在遇到时间的时候，用这个函数处理（比较
  • js实现前台动态添加文本框，后台获取文本框内容 171815164 文本框
    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://w
  • 持续集成工具 g21121 持续集成
            持续集成是什么？我们为什么需要持续集成？持续集成带来的好处是什么？什么样的项目需要持续集成？...        持续集成(Continuous integration ,简称CI)，所谓集成可以理解为将互相依赖的工程或模块合并成一个能单独运行
  • 数据结构哈希表(hash)总结 永夜-极光 数据结构
    1.什么是hash 来源于百度百科: Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。  
  • 乱七八糟 程序员是怎么炼成的
    eclipse中的jvm字节码查看插件地址： http://andrei.gmxhome.de/eclipse/ 安装该地址的outline 插件  后重启，打开window下的view下的bytecode视图 http://andrei.gmxhome.de/eclipse/   jvm博客： http://yunshen0909.iteye.com/blog/2
  • 职场人伤害了“上司” 怎样弥补 aijuans 职场
    由于工作中的失误，或者平时不注意自己的言行“伤害”、“得罪”了自己的上司，怎么办呢？ 　　在职业生涯中这种问题尽量不要发生。下面提供了一些解决问题的建议： 　　一、利用一些轻松的场合表示对他的尊重 　　即使是开明的上司也很注重自己的权威，都希望得到下属的尊重，所以当你与上司冲突后，最好让不愉快成为过去，你不妨在一些轻松的场合，比如会餐、联谊活动等，向上司问个好，敬下酒，表示你对对方的尊重，
  • 深入浅出url编码 antonyup_2006 应用服务器浏览器servletweblogicIE
    出处：http://blog.csdn.net/yzhz  杨争   http://blog.csdn.net/yzhz/archive/2007/07/03/1676796.aspx 一、问题：         编码问题是JAVA初学者在web开发过程中经常会遇到问题，网上也有大量相关的
  • 建表后创建表的约束关系和增加表的字段 百合不是茶 标的约束关系增加表的字段
      下面所有的操作都是在表建立后操作的,主要目的就是熟悉sql的约束,约束语句的万能公式   1,增加字段(student表中增加 姓名字段)   alter table 增加字段的表名 add 增加的字段名 增加字段的数据类型 alter table student add name varchar2(10);   &nb
  • Uploadify 3.2 参数属性、事件、方法函数详解 bijian1013 JavaScriptuploadify
    一.属性 属性名称 默认值 说明 auto true 设置为true当选择文件后就直接上传了，为false需要点击上传按钮才上传。 buttonClass ” 按钮样式 buttonCursor ‘hand’ 鼠标指针悬停在按钮上的样子 buttonImage null 浏览按钮的图片的路
  • 精通Oracle10编程SQL(16)使用LOB对象 bijian1013 oracle数据库plsql
    /* *使用LOB对象 */ --LOB(Large Object)是专门用于处理大对象的一种数据类型，其所存放的数据长度可以达到4G字节 --CLOB/NCLOB用于存储大批量字符数据，BLOB用于存储大批量二进制数据，而BFILE则存储着指向OS文件的指针 /* *综合实例 */ --建立表空间 --#指定区尺寸为128k,如不指定，区尺寸默认为64k CR
  • 【Resin一】Resin服务器部署web应用 bit1129 resin
    工作中，在Resin服务器上部署web应用，通常有如下三种方式：   配置多个web-app 配置多个http id 为每个应用配置一个propeties、xml以及sh脚本文件 配置多个web-app   在resin.xml中,可以为一个host配置多个web-app   <cluster id="app&q
  • red5简介及基础知识 白糖_ 基础
      简介   Red5的主要功能和Macromedia公司的FMS类似，提供基于Flash的流媒体服务的一款基于Java的开源流媒体服务器。它由Java语言编写，使用RTMP作为流媒体传输协议，这与FMS完全兼容。它具有流化FLV、MP3文件，实时录制客户端流为FLV文件，共享对象，实时视频播放、Remoting等功能。用Red5替换FMS后,客户端不用更改可正
  • angular.fromJson boyitech AngularJSAngularJS 官方APIAngularJS API
    angular.fromJson 描述: 把Json字符串转为对象 使用方法: angular.fromJson(json); 参数详解: Param Type Details json string JSON 字符串 返回值: 对象, 数组, 字符串 或者是一个数字 示例: <!DOCTYPE HTML> <h
  • java-颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I bylijinnan java
    public class ReverseWords { /** * 题目：颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I.词以空格分隔。 * 要求： * 1.实现速度最快,移动最少 * 2.不能使用String的方法如split,indexOf等等。 * 解答：两次翻转。 */ publ
  • web实时通讯 Chen.H Web浏览器socket脚本
    关于web实时通讯，做一些监控软件。 由web服务器组件从消息服务器订阅实时数据，并建立消息服务器到所述web服务器之间的连接，web浏览器利用从所述web服务器下载到web页面的客户端代理与web服务器组件之间的socket连接，建立web浏览器与web服务器之间的持久连接；利用所述客户端代理与web浏览器页面之间的信息交互实现页面本地更新，建立一条从消息服务器到web浏览器页面之间的消息通路
  • [基因与生物]远古生物的基因可以嫁接到现代生物基因组中吗? comsci 生物
          大家仅仅把我说的事情当作一个IT行业的笑话来听吧..没有其它更多的意思     如果我们把大自然看成是一位伟大的程序员,专门为地球上的生态系统编制基因代码,并创造出各种不同的生物来,那么6500万年前的程序员开发的代码,是否兼容现代派的程序员的代码和架构呢?   
  • oracle 外部表 daizj oracle外部表external tables
        oracle外部表是只允许只读访问，不能进行DML操作，不能创建索引，可以对外部表进行的查询，连接，排序，创建视图和创建同义词操作。 you can select, join, or sort external table data. You can also create views and synonyms for external tables. Ho
  • aop相关的概念及配置 daysinsun AOP
    切面(Aspect): 通常在目标方法执行前后需要执行的方法（如事务、日志、权限），这些方法我们封装到一个类里面，这个类就叫切面。 连接点（joinpoint） spring里面的连接点指需要切入的方法，通常这个joinpoint可以作为一个参数传入到切面的方法里面（非常有用的一个东西）。 通知（Advice） 通知就是切面里面方法的具体实现，分为前置、后置、最终、异常环
  • 初一上学期难记忆单词背诵第二课 dcj3sjt126com englishword
    middle 中间的，中级的 well 喔，那么；好吧 phone 电话，电话机 policeman 警察 ask 问 take 拿到；带到 address 地址 glad 高兴的，乐意的 why 为什么  China 中国 family 家庭 grandmother (外)祖母 grandfather (外)祖父 wife 妻子 husband 丈夫 da
  • Linux日志分析常用命令 dcj3sjt126com linuxlog
    1.查看文件内容 cat -n 显示行号 2.分页显示 more Enter 显示下一行 空格 显示下一页 F 显示下一屏 B 显示上一屏 less /get 查询"get"字符串并高亮显示 3.显示文件尾 tail -f 不退出持续显示 -n 显示文件最后n行 4.显示头文件 head -n 显示文件开始n行 5.内容排序 sort -n 按照
  • JSONP 原理分析 fantasy2005 JavaScriptjsonpjsonp 跨域
    转自 http://www.nowamagic.net/librarys/veda/detail/224 JavaScript是一种在Web开发中经常使用的前端动态脚本技术。在JavaScript中，有一个很重要的安全性限制，被称为“Same-Origin Policy”（同源策略）。这一策略对于JavaScript代码能够访问的页面内容做了很重要的限制，即JavaScript只能访问与包含它的
  • 使用connect by进行级联查询 234390216 oracle查询父子Connect by级联
    使用connect by进行级联查询          connect by可以用于级联查询，常用于对具有树状结构的记录查询某一节点的所有子孙节点或所有祖辈节点。          来看一个示例，现假设我们拥有一个菜单表t_menu，其中只有三个字段：
  • 一个不错的能将HTML表格导出为excel,pdf等的jquery插件 jackyrong jquery插件
    发现一个老外写的不错的jquery插件，可以实现将HTML 表格导出为excel,pdf等格式， 地址在： https://github.com/kayalshri/ 下面看个例子，实现导出表格到excel,pdf <html> <head> <title>Export html table to excel an
  • UI设计中我们为什么需要设计动效 lampcy UIUI设计
    关于Unity3D中的Shader的知识 首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，
  • 如何禁止页面缓存 nannan408 htmljspcache
    禁止页面使用缓存~ ------------------------------------------------ jsp:页面no cache： response.setHeader("Pragma","No-cache"); response.setHeader("Cache-Control","no-cach
  • 以代码的方式管理quartz定时任务的暂停、重启、删除、添加等 Everyday都不同 定时任务管理spring-quartz
          【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的 “暂停” 呢？暂停之后又要在某个时间点 “重启” 该定时任务呢？或者说直接 “删除” 该定时任务呢？要改变某定时任务的触发时间呢？ “添加” 一个定时任务对于系统的使用者而言，是不太现实的，因为一个定时任务的处理逻辑他是不
  • EXT实例 tntxia ext
      （1） 增加一个按钮   JSP:   <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); Stri
  • 数学学习在计算机研究领域的作用和重要性 xjnine Math
    最近一直有师弟师妹和朋友问我数学和研究的关系，研一要去学什么数学课。毕竟在清华，衡量一个研究生最重要的指标之一就是paper,而没有数学，是肯定上不了世界顶级的期刊和会议的，这在计算机学界尤其重要！你会发现，不论哪个领域有价值的东西，都一定离不开数学！在这样一个信息时代，当google已经让世界没有秘密的时候，一种卓越的数学思维，绝对可以成为你的核心竞争力.  无奈本人实在见地
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他