【Java SE】基础知识回顾——【3.常用类 | Static关键字】
【Java SE】基础知识回顾——【3.常用类 】
- Scanner/ArrayList/Random类
-
- Scanner类
-
- Scanner为例学习导入包的一般步骤
- 用Scanner输入三个数字比较最大值
- 匿名对象
-
- 匿名对象的定义
- 匿名对象作为方法的参数和返回值
- Random类
-
- Random类生成随机数字
- 猜测随机数
- ArrayList类
-
- ArrayList类的常用方法
- ArrayList的各种泛型
- ArrayList练习
- 用ArrayList集合类型作为方法参数
- static关键字、Arrays类、Math类
-
- Static关键字
-
- Static关键字修饰成员变量
- 调用静态方法
- 静态方法的内存图
- 静态代码块
- Arrays类
-
- Arrays类的几种方法
- 打印降序随机字符串：
- Math类
-
- Math类练习题
Scanner/ArrayList/Random类
Scanner类
Scanner 类是一个非常有用的工具，用于解析原始类型和字符串的文本输入。它在 java.util 包中，可以从多种输入源（如字符串、文件、流）读取数据。
| 方法 | 描述 |
|---|---|
next() |
查找并返回来自此扫描器的下一个完整标记 |
nextLine() |
返回此扫描器中当前行的剩余部分 |
nextInt() |
扫描下一个标记作为一个 int |
nextDouble() |
扫描下一个标记作为一个 double |
nextBoolean() |
扫描下一个标记作为一个 boolean |
hasNext() |
判断扫描器是否还有下一个标记 |
hasNextInt() |
判断下一个标记是否可以解析为 int |
hasNextLine() |
判断是否还有下一行 |
useDelimiter(String pattern) |
使用指定的模式设置此扫描器的分隔模式 |
close() |
关闭此扫描器 |
Scanner为例学习导入包的一般步骤
2021 3 26//package Demo02;
//01.导包
import java.util.Scanner;
public class Demo01Scanner {
public static void main(String[] args) {
//02.创建
Scanner sc = new Scanner(System.in);
//System.in代表从键盘输入
//03.获取键盘输入的int数字
System.out.println("数字绿色表示其为从键盘输入");
int num = sc.nextInt();
//这里的输入为int
System.out.println("输入的int类数字为：" + num);
//04.获取键盘输入的字符串
String str = sc.next();
//这里不管输入什么都算字符串
System.out.println("输入的字符串为："+str);
}
}
用Scanner输入三个数字比较最大值
2021 3 26package Demo02;
import java.util.Scanner;
/**
* @author 270
* 从键盘输入三个数字，求最大值
*/
public class Demo03ScannerSum {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] a = new int[3];
int max = a[0];
for (int i = 0; i < 3; i++) {
System.out.println("请输入第" + (i + 1) + "个数字：");
a[i] = sc.nextInt();
if (a[i] > max) {
max = a[i];
}
System.out.println("当前最大值为" + max);
}
}
}
匿名对象
匿名对象的定义
/**
* @author 270
* 创建对象的标准格式
* 类名称 对象名 = new 类名称（）；
*
* 匿名对象即只有右边的对象，没有左边的名字和赋值运算符
* 【注意】：匿名对象只能使用唯一的一次，下一次需要重新创建一个新的匿名对象
* 建议：如果确定一个对象只会使用一次，就可以用匿名对象
*/
public class Demo01Anonymous {
public static void main(String[] args) {
//正常对象，左边的one就是对象名字
Person one = new Person();
one.name = "心绘";
one.showName();
//匿名对象
new Person().name = "kaokaolao";
new Person().showName();
//上行数据会显示null，因为重新new了一次，换了对象
}
}
匿名对象作为方法的参数和返回值
package Demo03;
import org.w3c.dom.ls.LSOutput;
import java.sql.SQLOutput;
import java.util.Scanner;
/**
* @author 270
*/
public class Demo02Anonymous {
public static void main(String[] args) {
//普通使用方式
// Scanner sc = new Scanner(System.in);
// int num = sc.nextInt();
//匿名使用方式
// int num = new Scanner(System.in).nextInt();
//System.out.println("输入的是"+num);
//使用一般的方式传输参数
// Scanner sc = new Scanner(System.in);
// methodParam(sc);
//使用匿名对象进行传参
methodParam(new Scanner(System.in));
Scanner sc = methodReturn();
int num = sc.nextInt();
System.out.println("输入的是" + num);
}
public static void methodParam(Scanner sc) {
int num = sc.nextInt();
System.out.println("输入的是" + num);
}
public static Scanner methodReturn() {
//Scanner sc = new Scanner(System.in);
//return sc;
return new Scanner(System.in);
}
}
Random类
Random类生成随机数字
/** @author 270
* 用Random类用来生成随机数字
* 1.导包
* import java.util.Random;
* 2.创建
* Random r = new Random();
* 3.使用
* 获取一个随机的int数字。int num = r.nextInt();
* 获取一个范围内随机int数字。int num = r.nextInt(3);
* 3代表的是左闭右开区间，即取值为0，1，2。
*/
public class Demo01Random {
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt();
System.out.println("随机数是"+num);
}
}
package Demo01;
import java.util.Random;
/**
* @author 270
*/
public class Demo02Random {
public static void main(String[] args) {
Random r = new Random();
for (int i = 0; i < 100; i++) {
int num = r.nextInt(10);
//10的意思为从0-9选择
System.out.println(num);
}
}
}
2021 3 28package Demo01;
import java.util.Random;
import java.util.Scanner;
/**
* @author 270
* 根据int变量n的值，范围是【1，n】，1和n都可以取到
*/
public class Demo03Random {
public static void main(String[] args) {
Random r = new Random();
Scanner sc = new Scanner(System.in);
System.out.println("请输入随机数范围");
int n = sc.nextInt();
for (int i = 0; i < 100; i++) {
int result = r.nextInt(n)+1;
//这里整体加一则不会出现到零和n+1
//不能写nextInt（n+1），因为这样会出现0
System.out.println(result);
}
}
}
猜测随机数
package Demo01;
import java.util.Random;
import java.util.Scanner;
/**
* @author 270
* 猜随机数
*/
public class Demo04RandomGuess {
public static void main(String[] args) {
Random r = new Random();
int randomNum = r.nextInt(100)+1;
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 100; i++) {
System.out.println("第"+(i+1)+"次猜测");
int num = sc.nextInt();
if(randomNum>num){
System.out.println("猜小了");
}else if (randomNum<num){
System.out.println("猜大了");
}else{
System.out.println("回答正确");
break;
}
}
}
}
ArrayList类
package Demo02;
import java.util.ArrayList;
/**
* @author 270
* ArrayList
* 数组的长度不能改变//但是ArrayList集合的长度可以改变
*
*
* API文档用法：查询不同类的三个部分：
* 包括
* 1.所属包
* 2.查询方法
* 3.查询new对象的格式
*
* API文档中的ArrayList中的尖括号——表示泛型
* 表示装在集合中的所有元素都是同一个类型
* 【注意】：泛型只能是引用类型，不能是基本类型
*
*
* 【注意】：
* 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容
* 如果内容是空，得到的是空的中括号而不是地址—— []
*/
public class Demo03ArrayList {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list);
//此时Run程序会打印 []
//尖括号表示存储的元素全部为String
//备注：从JDK1.7+开始，右侧的尖括号内都可以不写内容，但是<>尖括号本身还是要写的
//向集合中添加一些数据，用到add方法。
list.add("坂田银时");
list.add("志村新八");
list.add("神乐");
System.out.println(list);
//list.add(100);
//错误写法，因为尖括号中的元素已经规定全部为字符串类型了
}
}
————打印结果：
[]
[坂田银时, 志村新八, 神乐]
ArrayList类的常用方法
| 方法 | 描述 |
|---|---|
add(E e) |
向列表的末尾添加指定的元素 |
add(int index, E element) |
在列表的指定位置插入指定元素 |
get(int index) |
返回列表中指定位置的元素 |
set(int index, E element) |
用指定元素替换列表中指定位置的元素 |
remove(int index) |
移除列表中指定位置的元素 |
remove(Object o) |
移除列表中首次出现的指定元素（如果存在） |
size() |
返回列表中的元素数 |
clear() |
移除列表中的所有元素 |
isEmpty() |
如果列表不包含元素，则返回 true |
contains(Object o) |
如果列表包含指定的元素，则返回 true |
indexOf(Object o) |
返回列表中首次出现的指定元素的索引，如果列表不包含该元素，则返回 -1 |
toArray() |
返回一个包含列表中所有元素的数组 |
ArrayList的各种泛型
2021 3 29/package Demo01;
import org.w3c.dom.ls.LSOutput;
import java.util.ArrayList;
/**
* @author 270
* 【注意】由于集合存储的是地址值，但是基本类型没有地址值。
* 所以泛型只能是引用类型而不能是基本类型
* 如果希望向集合中ArrayList中存储基本数据类型，必须使用基本类型对应的“包装类”
*
*
* 基本类型 包装类
* byte Byte
* short Short
* int Integer【特殊】
* long Long
* float Float
* double Double
* char Character【特殊】
* boolean Boolean
*
* 从jdk1.5+开始，支持自动装箱，自动拆箱。
* 自动装箱：基本类型----->包装类型
* 自动拆箱：包装类型----->基本类型
*
*/
public class Demo01ArrayListBasic {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//错误写法，泛型只能是引用类型，不能是基本类型
//ArrayList listB = new ArrayList<>();
ArrayList<Integer> listB = new ArrayList<>();
listB.add(100);
listB.add(200);
System.out.println(listB);
int num = listB.get(1);
System.out.println("第一号元素是"+num);
}
}
ArrayList练习
package Demo01;
import java.util.ArrayList;
import java.util.Random;
/**
* @author 270
* 生成六个1-33之间的随机整数，添加到集合并遍历
*/
public class Demo02Test {
public static void main(String[] args) {
Random random = new Random();
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 6; i++) {
list.add(random.nextInt(33)+1);
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
package Demo01;
import java.util.ArrayList;
/**
* @author 270
* 题目：自定义4个学生对象，添加到集合，并遍历
*
* 思路：
* 1.自定义Student学生类，四个部分
* 2.创建一个集合，用来储存学生对象。泛型
* 3.根据类，创建4个学生对象
* 4.将4个学生对象添加到集合当中
* 5.遍历集合：for，size，get
*/
public class Demo01Test {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student one = new Student("270",22);
Student two = new Student("cat",22);
Student three = new Student("dog",22);
Student four = new Student("pig",22);
list.add(one);
list.add(two);
list.add(three);
list.add(four);
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println("姓名"+stu.getName()+"年龄"+stu.getAge());
}
}
}
package Demo01;
import java.util.ArrayList;
/**
* @author 270
* 定义以指定格式打印集合的方法（ArrayList类型作为参数），
* 使用{}扩起来，使用@分隔每个元素
* 格式参照{元素@元素@元素}
*/
public class Demo02ArrayListPrint {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("270");
list.add("199");
list.add("111");
list.add("123");
System.out.println(list);
printArrayList(list);
//这里打印的格式为——[270, 199, 111, 123]；
//定义元素的三要素
//返回值类型：void
//方法名称：printArrayList
//参数列表：ArrayList
}
public static void printArrayList(ArrayList<String> list){
System.out.print("{");
for (int i = 0; i < list.size(); i++) {
String name = list.get(i);
if(i == list.size()-1){
System.out.print(name);
}else{
System.out.print(name+"@");
}
}
System.out.println("}");
}
输出结果：
[270, 199, 111, 123]
{270@199@111@123}
用ArrayList集合类型作为方法参数
package Demo01;
import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Random;
/**
* @author 270
* 題目：
* 用一个大集合存入20个随机数字，然后筛选偶数存入小集合
* 要求有自定义方法来筛选
*
* 1.创建一个集合用来存储int型
* 2.随机数字用Random
* 3.循环二十次，将其放入大集合：for，add
*/
public class Demo03ArrayListReturn {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 20; i++) {
list1.add(r.nextInt(100)+1);
//将1-100的随机数存放到大集合当中
}
ArrayList<Integer> list = evenChoose(list1);
System.out.println("只有偶数的小集合为："+list);
System.out.println("偶数总共有"+list.size()+"个");
}
public static ArrayList<Integer> evenChoose(ArrayList<Integer> list){
ArrayList list2 = new ArrayList<>();
for (int j = 0; j < list.size(); j++) {
if(list.get(j)%2 ==0){
list2.add(list.get(j));
}
}
return list2;
}
}
static关键字、Arrays类、Math类
Static关键字
Static关键字修饰成员变量
2021 3 31
package Demo01;
/**
* @author 270
* 如果一个成员变量使用了Static关键字，那么这个变量不再属于对象自己，
* 而是属于所在的类，多个对象共享一个类
*/
public class Demo01StaticField {
public static void main(String[] args) {
Student one = new Student("坂田银时",27);
Student two = new Student("土方十四郎",29);
Student.room = "1802教室";//room是静态关键字
System.out.println("姓名："+one.getName()
+",年龄："+one.getAge()+",教室:"+Student.room
+",学号："+one.getId());
System.out.println("姓名："+two.getName()
+",年龄："+two.getAge()+",教室:"+Student.room
+",学号："+two.getId());
}
}
打印结果：
姓名：坂田银时,年龄：27,教室:1802教室,学号：1
姓名：土方十四郎,年龄：29,教室:1802教室,学号：2
调用静态方法
package Demo01;
import Demo01.MyClass;
/**
* @author 270
* 一旦使用static修饰成员方法，那么这就成为了静态方法
* 静态方法不属于对象，而是属于类的。
*
* 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
*/
public class Demo02StaticMethod {
public static void main(String[] args) {
//首先创建对象
MyClass obj = new MyClass();
//然后才能调用没有static关键字的方法
obj.method();
//对于静态方法来说直接通过类名称调用
MyClass.methodStatic();
obj.methodStatic();
//不推荐第二种写法，虽然最后也能调用，但是可能被误认为是成员方法
}
}
package Demo01;
import Demo01.MyClass;
/**
* @author 270
* 一旦使用static修饰成员方法，那么这就成为了静态方法
* 静态方法不属于对象，而是属于类的。
*
* 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
*
* 无论是成员变量还是成员方法，如果有static关键字，都推荐用【类名称】来调用
* 静态方法：类名称.静态方法（）
* 静态变量：类名称.静态变量
*
* 【注意】：
* 1.静态不能直接访问非静态方法
* 原因：因为内存中【先】有的静态内容，【后】有的非静态内容
* 2.静态不能用this
* 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
* 而静态方法直接调用类名称，所以不用对象，所以要是通过
* 静态用了this会互相矛盾，是不对的。
*/
public class Demo02StaticMethod {
public static void main(String[] args) {
//首先创建对象
MyClass obj = new MyClass();
//然后才能调用没有static关键字的方法
obj.method();
//对于静态方法来说直接通过类名称调用
MyClass.methodStatic();
obj.methodStatic();
//对于本类当中的静态方法可以直接写方法名称
myMethod();
Demo02StaticMethod.myMethod();
//两条语句是等效的
}
public static void myMethod(){
System.out.println("这是一个自己的方法");
}
}
静态方法的内存图
【注意】：根据类名称访问静态成员变量的时候，全程跟对象没关系，只有类有关系
在这里插入图片描述
静态代码块
package Demo01;
/**
* @author 270
* 静态代码块的格式是：
*
* public class 类名称{
* static {
* //静态代码块的内容
* }
* }
*
* 特点：当第一次用到本类时，静态代码块执行【唯一】的一次。
* 【注意】：静态内容总是优先于非静态内容
* 静态代码块比构造方法先执行
*/
public class Demo01Static {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
}
执行结果：
静态代码块执行！
构造方法已执行
构造方法已执行
Arrays类
Arrays类的几种方法
package Demo02;
import java.util.Arrays;
/**
* @author 270
* iava.util.Array是一个与数组相关的工具类，
* 里面提供了大量的静态方法，用来实现数组的常见操作
*
* public static String toString（数组）：将参数数组变成字符串（按照默认格式：[元素1，元素2，...]）
* public static void sort(数组)，按照默认值升序【从小到大】对数组的元素进行排序
* 【备注】:
* 1.如果是数值，默认为升序从小到大
* 2.如果是字符串，sort默认按照字母排序
* 3.如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator的接口支持（今后学习）
*/
public class Demo01Arrays {
public static void main(String[] args) {
int[] array1 = {10, 20, 30};
String intStr = Arrays.toString(array1);
System.out.println(intStr);
System.out.println("===============");
int[] array2 = {2,1,46,27,80,5};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));
String[] array3 = {"bbb","ddd","cast"};
Arrays.sort(array3);
System.out.println(Arrays.toString(array3));
}
}
获取子数组
import java.util.Arrays;
public class hello {
public static void main(String[] args) {
int[] src = new int[]{1, 2, 3, 4, 5};
int newArray[] = Arrays.copyOfRange(src, 0, 2);
//这里的0和2是左闭右开的，表示子数组截取下标从0开始并小于2的所有元素
for (int i : newArray) {
System.out.println(i);
}
}
}
打印降序随机字符串：
package Demo02;
import java.util.Arrays;
import java.util.Random;
/**
* @author 270
* 用Arrays内APi对随机字符串进行升序排列，并倒序打印
*/
public class Demo02ArraysTest {
public static void main(String[] args) {
String str = "abcdefghijklmnopqrstuvwxyz";
Random r = new Random();
char[] charSource = str.toCharArray();
char[] charNum = new char[27];
for (int i = 0; i < charNum.length; i++) {
int a = r.nextInt(charSource.length);
charNum[i] = charSource[a];
}
Arrays.sort(charNum);
for (int i = charNum.length-1; i >=0; i--) {
System.out.print(charNum[i]);
}
}
}
Math类
package Demo01;
/**
* @author 270
* Math类在util包中，提供大量的静态方法解决一些数学问题
*
* 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 Demo01Math {
public static void main(String[] args) {
//获取绝对值
System.out.println(Math.abs(3.14));
System.out.println(Math.abs(-1.55));
System.out.println("===================");
//向上取整
System.out.println(Math.ceil(3.1));
System.out.println(Math.ceil(3.9));
System.out.println(Math.ceil(3.0));
System.out.println("===================");
//向下取整、抹零
System.out.println(Math.floor(30.99));
System.out.println(Math.floor(30.1));
System.out.println(Math.floor(29.5));
System.out.println("===================");
//四舍五入
System.out.println(Math.round(20.4));
System.out.println(Math.round(10.6));
}
}
Math类练习题
package Demo01;
/**
* 题目：
* 计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个
* */
public class Demo02MathTest {
public static void main(String[] args) {
int num = 0;
double min = -10.8;
double max = 5.9;
//这里通过强制转换（int）min来使i取到-10.8到5.9之间的所有整数
for (int i = (int)min; i <max; i++) {
if(Math.abs(i)>6||Math.abs(i)<2.1){
System.out.println(i+"的绝对值小于2.1或大于六");
num++;
}
}
System.out.println("这样的数共有："+num+"个");
}
}