跟我一起学JAVAEE吧——JAVA_SE篇——day06上课笔记（Scanner类、Random类、Arraylist集合、String基本用法）

day06

今天主要是三个常用类的用法，确实没多少知识点，全是一些练习

常用类——Scanner,Random,Arraylist

Scanner类

一个可以解析基本类型和字符串的简单文本扫描器

使用步骤：

导包
```
import java.util.Scanner
```
创建对象数据类型变量名 =new 数据类型(参数列表)
```
Scanner sc=new Scanner(System.in)
```
调用方法变量名.方法名
```
int i= sc.nextInt();
```

使用实例

import java.util.Scnaner;
public class Demo01Scanner{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int i = sc.nexInt();
        System.out.println("i="+i);
    }
}

String字符串
- String:定长字符串，长度不可以改变
  - concat(String str) 将指定的字符串连接的末尾
  - contains（CharSequence s）当且仅当此字符串包含指定的char值序列时才返回true
  - endsWith(String suffix) 测试此字符串是否以指定的后缀结尾
  - equals（Object anObject）将此字符串与指定对象进行比较//String类重写了equals比较值是否相等
  - indexOf（int ch)返回字符串第一次出现的字符串内的索引
  - lsatIndexOf（int ch）返回指定字符串的最后一次出现的字符串内的索引
  - replace（char oldChar,char newChar）返回从替换所有出现的导致一个字符串oldChar在此字符串newChar
  - split（Sting regex）将此字符串分割为给定的regular expression的匹配
  - vlaueOf 返回该数据原始数据类型
- StringBuilder和StringBuffer和String
  - String: 不可变序列
  - StringBuffer：可变字符序列，效率低，线程安全
  - StringBuilder：可变字符序列，效率高，线程不安全
  - 小结：
    - 如果要操作少量得数据用String
    - 多线程操作字符串缓冲区下操作大量数据 StringBuffer
    - 单线程操作字符串缓冲区下操作大量数据 StringBuilder

包装类：Java中的基本数据类型没有方法和属性，而包装类就是为了让这些拥有方法和属性，实现对象化交互。

基本类型	对应的包装
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

基本数据和包装类之间的转换
- 自动装箱：基本数据类型转换为包装类
- 自动拆箱：包装类转换为基本数据类型
基本数据类型和包装类的转换
- 通过包装类Integer.toString（）将整型转换为字符串
- 通过Integer.parseInt()将字符串转换为int类型
- 通过valueOf（）方法把字符串转换为包装类然后通过自动拆箱

Random类

例子（生成3个10以内的随机整数）

import java.util.random
public class Demo01Random{
public static void main(String[] args){
    Random r=new Random();
    for(int i=0;i<3;i++){
        int number = r.nextInt(10);
        System.out.println("number:"+number);
    }
}
}

获取随机数

import java.util.Random
    public class Test01Random{
        public static void main(String [] args){
            int n=50;
            Random r=new Random();
            nextint number = r.nextInt(n)+1;
            System.out.println("number:"+number);
        }
    }

猜数字

package cn.javase.day06;

import java.util.Random;
import java.util.Scanner;

public class Demoo03GuessNumber {
    public static int getNumber(){
        Random ran=new Random();
        int i=ran.nextInt(99)+1;
        return i;
    }
    public static void main(String[] args) {
        int []arr=new int[]{};
        int num =getNumber();
        while(true){
            int i=new Scanner(System.in).nextInt();
            if(i>num){
                System.out.println("数字大了");
            }else if(i<num){
                System.out.println("数字小了");
            }
            else if (i==num){
                System.out.println("恭喜你猜对了");
                break;
            }

        }
    }
}

ArrayList类

引入-对象数组

使用学生数组，存储三个学生对象，代码如下：

public class Student{
    private String name;
    public Student(){
    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    publicvoid setAge(int age) { 
        this.age = age;
    }
}
public class Test01StudentArray {
public static void main(String[] args) {
//创建学生数组
Student[] students = new Student[3];

//创建学生对象
	Student s1 = new Student("曹操",40);
    Student s2 = new Student("刘备",35);
    Student s3 = new Student("孙权",30);

//把学生对象作为元素赋值给学生数组students[0] = s1;
	students[1] = s2;
    students[2] = s3;

//遍历学生数组
for(int x=0; x<students.length; x++) { 
    Student s = students[x];
	System.out.println(s.getName()+"‐‐‐"+s.getAge());
}

}

//生成6个1-33之间的随机整数，添加到集合，并遍历
public class Test01ArrayList {
public static void main(String[] args) {
// 创建Random 对象
Random random = new Random();

// 创建ArrayList 对象
ArrayList<Integer> list = new ArrayList<>();

// 添加随机数到集合
for (int i = 0; i < 6; i++) {
	int r = random.nextInt(33) + 1;
    list.add(r);
}

// 遍历集合输出
for (int i = 0; i < list.size(); i++) { 
    System.out.println(list.get(i));
}
}
}

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

public class Test02ArrayList {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> list = new ArrayList<Student>();

//创建学生对象
Student s1 = new Student("赵丽颖",18); Student s2 = new Student("唐嫣",20); Student s3 = new Student("景甜",25); Student s4 = new Student("柳岩",19);

//把学生对象作为元素添加到集合中list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);

//遍历集合
for(int x = 0; x < list.size(); x++) { Student s = list.get(x);
System.out.println(s.getName()+"‐‐‐"+s.getAge());
}
}
}

打印集合方法

public class Test03ArrayList {
public static void main(String[] args) {
	// 创建集合对象
	ArrayList<String> list = new ArrayList<String>();

	// 添加字符串到集合中
	list.add("张三丰");
	list.add("宋远桥");
	list.add("张无忌");
	list.add("殷梨亭");

	// 调用方法
	printArrayList(list);
}

public static void printArrayList(ArrayList<String> list) {
	// 拼接左括号
	System.out.print("{");
	// 遍历集合
	for (int i = 0; i < list.size(); i++) {
	// 获取元素
		String s = list.get(i);
	// 拼接@符号
		if (i != list.size() ‐ 1) {
    	System.out.print(s + "@");
		} else {
		// 拼接右括号
		System.out.print(s + "}");
		}
	}
}

获取集合方法

public class Test04ArrayList {
public static void main(String[] args) {
// 创建Random 对象
	Random random = new Random();
	// 创建ArrayList 对象
	ArrayList<Integer> list = new ArrayList<>();

	// 添加随机数到集合
	for (int i = 0; i < 20; i++) {
		int r = random.nextInt(1000) + 1;	
   		 list.add(r);
	}
	// 调用偶数集合的方法
	ArrayList<Integer> arrayList = getArrayList(list); 						   		System.out.println(arrayList);
}

public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) {
	// 创建小集合,来保存偶数
	ArrayList<Integer> smallList = new ArrayList<>();

	// 遍历list
	for (int i = 0; i < list.size(); i++) {
	// 获取元素
		Integer num = list.get(i);
	// 判断为偶数,添加到小集合中
		if (num % 2 == 0){ 
    		smallList.add(num);
		}
	}
	// 返回小集合
	return smallList;
	}
}

今日作业

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

package cn.javase.day06;

import java.util.ArrayList;
import java.util.Random;

//1.	生成一个1~33的随机整数，添加到集合，并遍历集合
public class HomeWork01 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random ran = new Random();
        for (int i = 0; i < 33; i++) {
            list.add(ran.nextInt(32) + 1);
        }
        for (int j : list) {
            System.out.println(j);
        }
    }
}

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

package cn.javase.day06;

import java.util.ArrayList;

public class HomeWork02 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student s1 = new Student("小明", "18", "1");
        Student s2 = new Student("小花", "16", "2");
        Student s3 = new Student("小红", "17", "3");
        Student s4 = new Student("小白", "19", "4");
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        for (Student i : list) {
            System.out.println(i);
        }
    }
}

用一个集合存入20个随机数字，然后筛选其中的偶数，放在另一个集合中

package cn.javase.day06;

import java.util.ArrayList;
import java.util.Random;

//3.	用一个集合存入20个随机数字，然后筛选其中的偶数，放在另一个集合中
public class HomeWork03 {
    public static void main(String[] args) {
        ArrayList<Integer> cardinalNumber = new ArrayList();
        ArrayList<Integer> even = new ArrayList();
        Random ran = new Random();
        for (int i = 0; i < 20; i++) {
            int j = ran.nextInt(99) + 1;
            if (j % 2 == 1) {
                cardinalNumber.add(j);
            } else {
                even.add(j);
            }
        }
        for (int i : cardinalNumber) {
            System.out.println(i);
        }
        System.out.println("——————————");
        for (int i : even) {
            System.out.println(i);
        }
    }
}

给定一个String类型的路径判断有几层目录并且判断是否是以.java结尾，是的话返回true，不是返回false，然后判断是否包含一个servlets的目录

A:\AAA\apache-tomcat-8.5.55\webapps\examples\servlets\images\code\code.gif

package cn.javase.day06;

/*4.	给定一个String类型的路径判断有几层目录并且判断是否是以.java结尾，
是的话返回true，不是返回false，然后判断是否包含一个servlets的目录
A:\AAA\apache-tomcat-8.5.55\webapps\examples\servlets\images\code\code.gif*/
public class HomeWork04 {
    public static void main(String[] args) {
        String path="A:\\AAA\\apache-tomcat-8.5.55\\webapps\\" +
                "examples\\servlets\\images\\code\\code.gif";
        boolean ends=path.endsWith(".java");
        int count=0;
        boolean servlets;
        int index=0;
        while (true){
            int i=path.indexOf("\\",index);
            int j=path.indexOf("servlets",0);//判断是否有这个字符串
            if(j!=-1){
                servlets=true;
            }
            else {
                servlets=false;
            }
            if(i==-1){//没找到返回-1
                break;
            }
            count++;
            index=i+1;//找到后从下一个下标开始
            if(index>path.length()-1){//判断是否结束
                break;
            }

        }
        System.out.println("此目录有"+count+"层，"+"以.java结尾："+ends+",servlet目录："+servlets);
    }
}

此目录有8层，以.java结尾：false,servlet目录：true

给定一个String类型字符串ertyesguiosefesgdfgadwesfhjklefg 判断其中es出现了几次，并返回第一次出现的位置

package cn.javase.day06;
//5.	给定一个String类型字符串ertyesguiosefesgdfgadwesfhjklefg 判断其中es出现了几次，并返回第一次出现的位置
public class HomeWork05 {
    public static void main(String[] args) {
        String str="ertyesguiosefesgdfgadwesfhjklefg";
        int count=0,temp=0,first=0;

        while (true){
            int i=str.indexOf("es",temp);
            temp=i+2;

            if(i==-1){
                break;
            }
            count++;
            if(i>str.length()-1){
                break;
            }

        }
        System.out.println("出现了"+count+"次，"+"第一次出现的的下标："+str.indexOf("es",temp));
    }
}

出现了3次，第一次出现的的下标：4

在ArrayList中存储Student类型的一些学生对象，判断如果有姓名，年龄，性别都相同的将其删除(比如：存学生对象，同姓名同年龄，视为同一个人，为重复元素。)

//Student的JavaBean规范，并重写equals方法
package cn.javase.day06;

import java.util.Objects;

public class Student {
    private String name;
    private String age;
    private String number;

    public Student() {
    }

    public Student(String name, String age, String number) {
        this.name = name;
        this.age = age;
        this.number = number;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name) &&
                Objects.equals(age, student.age) &&
                Objects.equals(number, student.number);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", number='" + number + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }
}

package cn.javase.day06;

import java.util.ArrayList;

public class HomeWork06 {
    //6.	在ArrayList中存储Student类型的一些学生对象，判断如果有姓名，年龄，性别都相同的将其删除(比如：存学生对象，同姓名同年龄，视为同一个人，为重复元素。)
    public static void main(String[] args) {
        ArrayList<Student>list=new ArrayList<>();
        Student s1 = new Student("小明", "18", "1");
        Student s2 = new Student("小花", "16", "2");
        Student s3 = new Student("小红", "17", "3");
        Student s4 = new Student("小明", "18", "1");
        Student s5 = new Student("小白", "19", "4");
        Student s6 = new Student("小白", "19", "4");
        Student s7 = new Student("小花", "16", "2");
        Student s8 = new Student("小明", "18", "1");
        Student s9 = new Student("小红", "17", "3");
        Student s10 = new Student("小白", "19", "4");
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        list.add(s6);
        list.add(s7);
        list.add(s8);
        list.add(s9);
        list.add(s10);
        for(Object o:list){
            System.out.println(o);
        }
        for (int i=0;i<list.size()-1;i++){
            for(int j=1;j<list.size();j++){
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                }
            }
        }
        System.out.println("——————————————");
        for (Object o:list){
            System.out.println(o);
        }
    }
}

Student{name='小明', age='18', number='1'}
Student{name='小花', age='16', number='2'}
Student{name='小红', age='17', number='3'}
Student{name='小明', age='18', number='1'}
Student{name='小白', age='19', number='4'}
Student{name='小白', age='19', number='4'}
Student{name='小花', age='16', number='2'}
Student{name='小明', age='18', number='1'}
Student{name='小红', age='17', number='3'}
Student{name='小白', age='19', number='4'}
——————————————
Student{name='小明', age='18', number='1'}
Student{name='小红', age='17', number='3'}
Student{name='小白', age='19', number='4'}
Student{name='小花', age='16', number='2'}

跟我一起学JAVAEE吧——JAVA_SE篇——day06上课笔记（Scanner类、Random类、Arraylist集合、String基本用法）

常用类——Scanner,Random,Arraylist

今日作业

猜你喜欢