引用类型的一般使用步骤:
- 导包
import 包路径.类名称
如果需要使用的目标类,与当前类在同一个包下,则可以省略导包语句不写。
只有java.lang包下的内容不需要导包,其他的包都需要import语句。 - 创建
类名称 对象名=new 类名称();
- 使用
对象名.成员方法名()
Scanner类
功能:键盘输入,将数据从键盘输入录入到程序当中
public class Demo01Scanner {
public static void main(String[] args) {
//2. 创建
Scanner sc=new Scanner(System.in); // System.in代表从键盘进行输入
//3. 使用
//获取键盘输入的一个int数字:int num=sc.nextInt();
int num=sc.nextInt();
System.out.println("输入的int数字是"+num);
//获取键盘输入的一个字符串:String str=sc.next();
String str=sc.next();
System.out.println("输入的字符串是"+str);
}
}
练习:键盘输入三个int数字,求出其中最大值
package cn.itcast.day07.demo01;
import java.util.Scanner;
public class Demo03ScannerMax {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("依次输入三个数字:");
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
int temp= a>b?a:b;
int max=temp>c?temp:c;
System.out.println("最大值为:"+max);
}
}
输出结果:
匿名对象
创建对象的标准格式:类名称 对象名=new 类名称();
匿名对象:只有右边的对象,没有左侧的对象名和赋值运算符
new 类名称();
匿名对象只能使用唯一的一次,下次使用必须再创建一个新对象
使用建议:如果确定有一个对象,确定只使用唯一的一次,可使用匿名对象
public class Demo01Anonymous {
public static void main(String[] args) {
//使用匿名对象
new Person().name="赵又廷";
new Person().showName();
}
}
public class Person {
String name;
public void showName(){
System.out.println("我叫:"+name);
}
}
输出结果:相当于new了两个对象,第一个对象.name,并没有赋值给第二个对象
使用匿名对象作为方法的参数
package cn.itcast.day07.demo02;
import java.util.Scanner;
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));
}
public static void methodParam(Scanner sc){
int num = sc.nextInt();
System.out.println("输入的是:"+num);
}
使用匿名对象作为方法的返回值
package cn.itcast.day07.demo02;
import java.util.Scanner;
public class Demo02Anonymous {
public static void main(String[] args) {
Scanner sc = methodReturn();
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类作用:生成随机数字
使用:
- 导包
import java.util.Random
- 创建
Random r=new Random();
- 使用
获取一个随机的int数字(范围是int所有范围,有正负两种):int num=r.nextInt();
获取一个随机的int数字(参数代表了范围,左闭右开区间):int num=r.nextInt(3); //指[0,3)
练习1:根据int变量n的值,来获取随机数字,范围是[1,n]
package cn.itcast.day07.demo03;
import java.util.Random;
/* 题目:根据int变量n的值,来获取随机数字,范围是[1,n] */
public class Demo03Random {
public static void main(String[] args) {
int n=5;
Random r=new Random();
for (int i = 0; i < 100; i++) {
//原本范围是[0,n),整体+1后变成[1,n+1),也就是[1,n]
int result=r.nextInt(n)+1;
System.out.println(result);
}
}
}
练习2:用代码模拟猜数字的小游戏
package cn.itcast.day07.demo03;
import java.util.Random;
import java.util.Scanner;
/*
题目:用代码模拟猜数字的小游戏
思路:
1. 首先产生一个随机数字,一旦产生不再变化,用Random.nextInt()方法
2. 需要键盘输入,所以使用Scanner
3. 获取键盘输入的数据,用Scanner.nextInt()方法
4. 对获取的两个数字进行判断(if)
如果太大,提示太大,并重试
如果太小,提示太小,并重试
如果猜中了,游戏结束
5. 重试即循环,循环次数不确定,用while(true)
*/
public class Demo04RandomGame {
public static void main(String[] args) {
Random r=new Random();
int randomNum=r.nextInt(100)+1;
Scanner sc=new Scanner(System.in);
while(true){
System.out.println("请输入你猜测的数字:");
int guessNum=sc.nextInt();
if(guessNum>randomNum){
System.out.println("太大了,请重试");
}else if(guessNum<randomNum){
System.out.println("太小了,请重试");
}else{
System.out.println("恭喜你,猜中啦!");
break;
}
}
System.out.println("游戏结束!");
}
}
ArrayList集合
-
任何数据类型都可以作为数组当中元素的类型。但数组的长度不可以发生改变
ArrayList集合的长度是可以随意变化的 -
ArrayList< E >,其中< E >代表泛型。即装在集合里的所有元素,都是统一的某一类型,泛型只能是引用类型,不能是基本类型(集合里保存的都是地址值,基本类型数据没有地址值)
若希望想集合存储基本类型数据,必须使用基本类型对应的“包装类”
基本类型 包装类(引用类型,包装类都位于java.lang) byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 从JDK 1.5+开始,支持自动装箱、自动拆箱
自动装箱:基本类型自动变成包装类型
自动拆箱:包装类型自动拆为基本类型
- 对于ArrayList集合来说,直接打印得到的不是地址值,而是内容。
如果内容为空,得到的是空的中括号[ ]
public class Demo01ArrayList {
public static void main(String[] args) {
//创建了一个ArrayList集合,集合的名称是list,里面装的全是String字符串类型的数据
//备注:从jdk1.7+开始,右侧<>内部可不写内容,但<>本身还是要写的
ArrayList<String> list=new ArrayList<>();
System.out.println(list);
}
}
输出:
ArrayList常用方法
public boolean add(E e)
:向集合中添加元素,参数类型和泛型一致,返回值代表是否添加成功
备注:对于ArrayList集合来说,add添加动作一定是成功的,所以返回值可用可不用。
但对于其他集合(今后学习)来说,add添加动作不一定成功
public E get(int index)
:从集合当中获取元素,参数是索引编号,返回值是对应位置的元素
public E remove(int index)
:从集合中删除元素,参数是索引编号,返回值是被删除掉的元素
public int size()
:获取集合的尺寸长度,返回值是集合中包含的元素个数
package cn.itcast.day07.demo04;
import java.util.ArrayList;
public class Demo03ArrayListMethod {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
System.out.println(list);
//向集合中添加元素
boolean success=list.add("刘一");
System.out.println(list); //[刘一]
System.out.println("添加的动作是否成功:"+success);
list.add("王二");
list.add("张三");
list.add("李四");
System.out.println(list); //[刘一, 王二, 张三, 李四]
//从集合中获取元素,get,索引值从0开始
String name=list.get(2);
System.out.println("第2号索引位置:"+name);
//从集合中删除元素,remove,索引值从0开始
String whoRemoved = list.remove(2);
System.out.println("被删除的人是:"+whoRemoved);
System.out.println(list);
//获取集合长度
int size=list.size();
System.out.println("集合的长度是:"+size);
}
}
输出:
遍历集合:
package cn.itcast.day07.demo04;
import java.util.ArrayList;
public class Demo04ArrayListEach {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
//遍历集合
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
练习1:
package cn.itcast.day07.demo05;
import java.util.ArrayList;
/*
题目:自定义4个学生对象,添加到集合,并遍历
思路:
1. 自定义学生类Student,四个部分
2. 创建集合存储学生对象,泛型,<Student>
3. 根据类,创建4个学生对象
4. 将4个学生对象添加到集合中,add
5. 遍历集合,for,size,get
*/
public class Demo01ArrayListStudent {
public static void main(String[] args) {
ArrayList<Student> list=new ArrayList<>();
Student one=new Student("刘一",20);
Student two=new Student("王二",21);
Student three=new Student("张三",22);
Student four=new Student("李四",23);
list.add(one);
list.add(two);
list.add(three);
list.add(four);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
Student stu=list.get(i);
System.out.println("姓名:"+stu.getName()+",年龄:"+stu.getAge());
}
}
}
练习2:
package cn.itcast.day07.demo05;
import java.util.ArrayList;
/*
题目:定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}括起来,使用@分隔每个元素
格式参照:{元素@元素@元素}
*/
public class Demo03ArrayListPrint {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("刘一");
list.add("王二");
list.add("张三");
list.add("李四");
System.out.println(list); //[刘一, 王二, 张三, 李四]
printArrayList(list);
}
//集合也可以作为方法的参数,传递的参数为地址值
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.println(name+"}");
}else {
System.out.print(name+"@");
}
}
}
}
练习3:集合无论做参数还是返回值,传递和接受的都是地址值
package cn.itcast.day07.demo05;
import java.util.ArrayList;
import java.util.Random;
/*
题目:用一个大集合存入20个随机数字,然后筛选其中的偶数元素,放到小集合当中
要求:用自定义的方法实现元素的筛选
思路:
1. 需要创建一个集合,用来存储int数字,<Integer>
2. 随机数字,Random.nextInt()
3. 循环20次,把随机数字存入大集合,for循环,add方法
4. 自定义方法,筛选元素
*/
public class Demo04ArrayListReturn {
public static void main(String[] args) {
ArrayList<Integer> bigList=new ArrayList<>();
Random r=new Random();
for (int i = 0; i < 20; i++) {
int num=r.nextInt(100)+1; //1-100
bigList.add(num);
}
ArrayList<Integer> result=getSmallList(bigList);
System.out.println(result);
System.out.println("偶数一共有多少个:"+result.size());
}
//接受大集合参数,返回小集合结果
//集合无论做参数还是返回值,传递和接受的都是地址值
public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList){
ArrayList<Integer> smallList=new ArrayList<>();
for (int i = 0; i < bigList.size(); i++) {
int num=bigList.get(i);
if(num%2==0){
smallList.add(num);
}
}
return smallList;
}
}
String类
Java程序中所有字符串字面值(如"abc")都作为此类的实例实现。
即,程序当中所有的双引号字符串,都是String类的对象,即使没有new
字符串特点:
- 字符串是常量,它们的值在创建后不能更改
- 因为字符串不可改变,所以字符串是可以共享使用的
- 字符串效果上相当于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={'A','B','C'};
String str2=new String(charArray);
System.out.println("第二个字符串:"+str2);
//根据字节数组创建字符串
byte[] byteArrays={97,98,99};
String str3=new String(byteArrays);
System.out.println("第三个字符串:"+str3);
//直接创建
String str4="Hello";
System.out.println("第四个字符串:"+str4);
}
}
//输出结果为:
//第一个字符串:
//第二个字符串:ABC
//第三个字符串:abc
//第四个字符串:Hello
字符串常量池
字符串常量池:程序当中直接写上的双引号字符串,在字符串常量池中.new的不在常量池中
对于基本类型来说,==是进行数值的比较
对于引用类型来说,==是进行地址值比较
public class Demo01StringPool {
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
}
}
上述程序的内存图如下:
//下述代码中,字符串的内容是没有改变的,其实是产生了两个字符串“Hello”和“Java”
//str1 中起初保存的是“Hello”的地址值,后来变成了“Java”的地址值
public class DemoString {
public static void main(String[] args) {
String str1 = "Hello";
System.out.println(str1); //Hello
str1 = "Java";
System.out.println(str2); //Java
}
}
字符串的常用方法
-
字符串的内容比较:
public boolean equals(Object obj)
:只有参数是一个字符串且内容相同(严格区分大小写)时返回 true,否则返回false
public boolean equalsIgnoreCase(String str)
:忽略大小写,进行内容比较注意:equals() 方法具有对称性,a.equals(b) 和 b.equals(a) 效果相同。但如果比较双方一个常量一个变量,推荐将常量字符串写在前面
推荐:"abc".equals(str);"
不推荐:str.equals("abc");
//原因:若字符串对象为空时 String str = null; System.out.println("abc".equals(str)); //推荐写法,会返回false System.out.println(str.equals("abc"); //不推荐写法,会报错:空指针异常NullPointerException
-
字符串的内容获取
public int length()
:获取字符串的长度
public String concat()
: 将当前字符串与参数字符串拼接成新的字符串并返回
public char charAt(int index)
:获取指定索引位置的单个字符(索引从0开始)
public int indexOf(String str)
:查找参数字符串在本字符串中首次出现的索引位置,没有则返回-1 -
字符串的截取
public String substring(int index)
:截取从参数位置一直到字符串末尾,返回新的字符串
public String substring(int begin, int end)
:截取从 begin 开始,一直到 end 结束中间的字符串。[begin, end),包含 begin,不包含 end -
字符串的转换
public char[] toCharArray()
:将当前字符串拆分为字符数组并返回
public byte[] getBytes()
:获取当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString)
:将所有出现的老字符串替换为新字符串,并返回替换后的新字符串结果 。(CharSequence是说可以接受字符串类型。CharSequence是一个接口,实现了这个接口的类有:CharBuffer、String、StringBuffer、StringBuilder这个四个类。)
public class Demo01StringConvert {
public static void main(String[] args) {
//转换成字节数组
byte[] bytes = "abc".getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]); //97 98 99
}
//字符串的内容替换
String str1 = "How do you do?";
String str2 = str1.replace("o","*");
System.out.println(str1); //How do you do?
System.out.println(str2); //H*w d* y*u d*?
}
}
- 字符串的分隔
public String[] split(String regex)
:按照参数的规则,将字符串分割为若干部分
注意:split 方法的参数其实是一个正则表达式
public class Demo01StringSplit {
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
}
String str2 = "aaa.bbb.ccc";
String[] array2 = str2.split("."); //根据"."分隔失败,非正则表达式
System.out.println(((String[]) array2).length); //0
String[] array3 = str2.split("\\."); //采用正则表达进行分隔
for (int i = 0; i < array3.length; i++) {
System.out.println(array3[i]); //aaa bbb ccc
}
}
}
练习一:
/*
* 定义一个方法,将数组[1,2,3]按照指定格式拼接成一个字符串。指定格式为:[word1#word2#word3]
*/
public class Demo01StringPractise {
public static void main(String[] args) {
int[] array = {1,2,3};
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;
}
}
练习二:
/*
* 题目:键盘输入一个字符串,统计字符串中各种字符出现的次数
* 类型包括:大写字母,小写字母,数字,其他
* */
public class Demo01StringCount {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.next();
int countUpper = 0;
int countLower = 0;
int countNum = 0;
int countOther = 0;
char[] charArray = input.toCharArray();
for (int i = 0; i < charArray.length; i++) {
char ch = charArray[i];
if('A' <= ch && ch <= 'Z') {
countUpper++;
} else if ('a' <= ch && ch <= 'z') {
countLower++;
} else if ('0' <= ch && ch <= '9') {
countNum++;
} else {
countOther++;
}
}
System.out.println("大写子母有" + countUpper +"个");
System.out.println("小写子母有" + countLower +"个");
System.out.println("数字有" + countNum +"个");
System.out.println("其他有" + countOther +"个");
}
}
静态static关键字
static关键字概述:一旦用了static关键字修饰,所修饰的内容不再属于对象自己,而是属于类,凡是本类的对象都共享同一份
static 修饰成员变量
如果一个成员变量使用了static关键字,则这个变量不属于对象本身,而是属于所在类,多个对象共享同一个数据
public class Student {
private String name;
private int age;
static String room;
private int id; //学号
private static int idCounter = 0; //学号计数器
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
public Student(){
idCounter++;
}
public int getId() { return id;}
public void setId(int id) { this.id = id;}
public void setName(String name) { this.name = name;}
public void setAge(int age) { this.age = age;}
public String getName() { return name;}
public int getAge() { return age;}
}
public class Demo01StaticField {
public static void main(String[] args) {
Student stu1 = new Student("张三",18);
stu1.room = "101"; //对静态成员变量赋值
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());
}
}
//Output:
//姓名:张三,年龄:18,教室:101,学号:1
//姓名:李四,年龄:20,教室:101,学号:2
static 修饰成员方法
一旦使用 static 修饰成员方法,则该方法为静态方法,属于类本身,而不属于对象
对于静态方法,可以直接通过类名调用,也可以通过对象名调用(不推荐)
没有 static 修饰的非静态方法,必须首先创建对象,才能通过对象使用它
public class MyClass {
public void method() {
System.out.println("这是一个普通方法");
}
public static void methodStatic() {
System.out.println("这是一个静态方法");
}
}
public class Demo01StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass();
obj.method(); //非静态方法
obj.methodStatic(); //静态方法,但不推荐。这种写法在编译后也会被javac翻译为"类名.静态方法名"
MyClass.methodStatic(); //静态方法,推荐使用
myMethod();
}
public static void myMethod(){
System.out.println("自己的方法!");
}
}
无论是静态成员变量还是静态成员方法,都推荐使用类名调用
类名称.静态变量
类名称.静态方法()
对于本类当中的静态方法,可以省略类名称
注意:
- 静态不能直接访问非静态(原因:在内存当中,先有的静态内容,后有的非静态内容)
- 静态方法当中不能用this关键字(原因:this代表当前对象)
public class MyClass {
int num;
static int myStatic;
public void method() {
System.out.println("这是一个普通方法");
//成员方法可以访问成员变量
System.out.println(num);
//成员方法可以访问静态成员变量
System.out.println(myStatic);
}
public static void methodStatic() {
System.out.println("这是一个静态方法");
//静态方法不能访问非静态变量
//System.out.println(num);
//静态方法可以访问静态变量
System.out.println(myStatic);
}
}
静态 static 的内存图如下:
静态代码块
静态代码块的典型用途:用来一次性对静态成员变量进行赋值
public class 类名称 {
static {
//静态代码块内容
}
}
在第一次执用到本类时,静态代码块执行唯一的一次
静态内容总是优先于非静态。
public class Person {
static {
System.out.println("静态代码块执行");
}
public Person() {
System.out.println("构造方法执行");
}
}
public class Demo01Static {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
}
//Output:
//静态代码块执行
//构造方法执行
//构造方法执行
数据工具类Arrays
java.util.Arrays 是一个与数组有关的工具类,里面提供了大量的静态方法,用来实现数组的常见操作
public static String toString(数组)
:将参数数组变为字符串(按照默认格式:[元素1,元素2,元素3…])public static void sort(数组)
:按照默认升序(从小到大)对数组元素进行排序
public static void main(String[] args) {
//将int[]数组按照默认格式变成字符串
int[] array1 = {10,20,30};
String str = Arrays.toString(array1);
System.out.println(str); //[10, 20, 30]
int[] array2 = {4,6,2,9,5,1};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2)); //[1, 2, 4, 5, 6, 9]
String[] array3 = {"bbb","aaa","ccc"};
Arrays.sort(array3);
System.out.println(Arrays.toString(array3)); //[aaa, bbb, ccc]
}
}
- 如果是数值,sort默认按照升序从小到大
- 如果是字符串,sort默认按照字母升序
- 如果是自定义类型,那么这个自定义的类需要有Comparable或者Comparator接口的支持
数学工具类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(-4.2)); //4.2
//向上取整
System.out.println(Math.ceil(3.43)); //4.0
//向下取整
System.out.println(Math.floor(-5.64)); //-6.0
//四舍五入
System.out.println(Math.round(6.34)); //6
System.out.println(Math.round(-5.67)); //-6
}
}