笔记-迎难而上之Java基础进阶3
统计字符串中每一个不同的字符
import java.util.*;
//统计字符串每一个字符出现的字数
public class StringDemo{
public static void main(String[] args){
Scanner aScanner = new Scanner(System.in);
//让用户输入字符串
System.out.println("请输入你要统计的语句");
String aString = aScanner.next();
//要统计每一个字符，就要把字符串转换为字符,可以调用字符串的方法toCharArray
char[] aCharArray = aString.toCharArray();
//创建HashMap集合，让其存储键与值
HashMap<Character,Integer> aHashMap = new HashMap<>();
//遍历字符数组
for(Character key:aCharArray){
//把aChar作为键，先判断集合中有没有该键，若有则value加一，没有的话添加键进去
if(aHashMap.containsKey(key)){
Integer value =aHashMap.get(key);
value++;
//后来的值会取代前面的值，put方法把值添加进去，
aHashMap.put(key,value);
}else{
//不存在添加进去
aHashMap.put(key,1);
}
}
//把key存储都Set集合中，遍历集合
Set<Character> aSet = aHashMap.keySet();
//遍历aHashMap
for(Character key : aSet){
Integer value = aHashMap.get(key);
System.out.println(key+"="+value);
}
}
}
JDK9的新特性：
List接口，Set接口，Map接口里边增加了一个静态方法of,可以给集合一次性添加多个元素
使用前提：当集合中存储的元素的个数已经确定了，不再改变使用，也就是说，添加完元素之后，就不能再使用put方法来添加元素了
注意事项：
-
of方法只适用于List接口，Set接口，Map接口，不适用于接口的实现类
-
of方法的返回值是一个不能够改变的集合
-
Set接口和Map接口在调用of方法适合，不能存放重复元素，否则会抛出异常
import java.util.*;
public class JDK9Demo{
public static void main(String[] args){
List<String> list = List.of("a","b","c","d","a");//可以重复元素
System.out.println(list);
Set<String> set = Set.of("a","b","c");//不允许重复元素
System.out.println(set);
Map<String,Integer> map = Map.of("张三",18,"李四",17,"王五",16,"赵三",18);//不允许重复元素,键不允许重复，值可以
System.out.println(map);
}
}
Debug追踪
Debug调试程序
可以让代码逐行执行，查看代码执行的过程，调试程序中出现的bug
f8:逐行执行程序 f7：进入到方法中 shift+f8跳出方法
f9：跳到下一个断点 ctrl +f2 退出debug模式,停止程序
console：切换到控制台
斗地主案列
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
public class DouDiZhu {
public static void main(String[] args){
//Integer表示的索引，String表示牌的大小
HashMap<Integer,String> poker = new HashMap<>();
//创建一个List集合，存储牌的索引,sort方法可以对索引进行排序
ArrayList<Integer> pokerIndex = new ArrayList<>();
//定义两个集合，存储花色和牌的序号
List<String> colors = List.of("♠","♥","♣","♦");
List<String> numbers = List.of("2","A","K","Q","J","10","9","8","7","6","5","4","3");
//把大小王存储到集合中
int index = 0;
poker.put(index,"大王");
pokerIndex.add(0);
index++;
poker.put(index,"小王");
pokerIndex.add(index);
index++;
//0索引代表着大王，1索引代表着小王，以此类推，到后面就可以对索引排序，也就是对牌排序
for(String number : numbers){
for(String color :colors){
String str = color+number;
poker.put(index,str);
//牌的索引也要添加,因为他代表着牌的大小，
pokerIndex.add(index);
index++;
}
}
//使用Collections中的方法shuffle();
Collections.shuffle(pokerIndex);
ArrayList<Integer> p1 = new ArrayList<>();
ArrayList<Integer> p2 = new ArrayList<>();
ArrayList<Integer> p3 = new ArrayList<>();
ArrayList<Integer> p4 = new ArrayList<>();
for(int i=0;i <pokerIndex.size();i++){
//先转为Integer类型，不然会添加失败
Integer in = pokerIndex.get(i);
if(i>=51){
p4.add(in);
}else if(i%3==0){
p1.add(in);
}else if(i%3==1){
p2.add(in);
}else if(i%3==2){
p3.add(in);
}
}
//把分完的牌进行排序
Collections.sort(p1);
Collections.sort(p2);
Collections.sort(p3);
Collections.sort(p4);
lookPoker("刘德华",poker,p1);
lookPoker("周润发",poker,p2);
lookPoker("周星驰",poker,p3);
lookPoker("底牌",poker,p4);
}
public static void lookPoker(String name,HashMap<Integer,String> poker,ArrayList<Integer> list){
System.out.print(name+": ");
for(Integer key : list){
//通过索引获取值
String value = poker.get(key);
System.out.print(value+" ");
}
System.out.println();
}
}
异常
Throwable有两个子类Exception和Error
Error：严重错误error，无法通过处理的错误，只能实现避免，好比绝症
Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的
throw关键字可以在指定的方法里面抛出指定的异常对象
/*
throw关键字
作用：
可以使用throw关键字在指定的方法中抛出指定的异常
使用格式：
throw new xxxException（"异常产生的原因"）；
注意：
1.throw关键字必须写在方法的内部
2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
3.throw关键字抛出指定的异常对象，我们必须处理这个异常对象
throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给jvm处理
throw关键字后边创建的是编译器异常，我们必须处理这个异常，
*/
public class ThrowDemo{
public static void main(String[] args){
int[] arr= new int[3];
int e = getElement(arr,-2);
System.out.println(e);
//抛出指定了异常
//Exception in thread "main" java.lang.NullPointerException: 传递的数组是空
//at ThrowDemo.getElement(ThrowDemo.java:24)
//at ThrowDemo.main(ThrowDemo.java:18)
}
//如果传递的参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递参数有问题
public static int getElement(int[] arr,int index){
if(index<0 || index>arr.length-1){
throw new ArrayIndexOutOfBoundsException("传递的索引不能超过范围或者低于范围");
}
if(arr == null){
//如果是空，就指定他为空指针异常
throw new NullPointerException("传递的数组是空");
}
int i = arr[index];
return i;
}
}
Objects的非空判断
Objects.requireNonNull();可以判断一个对象是否为null
import java.util.Objects;
public class ThrowDemo{
public static void main(String[] args){
method("云想衣裳花想容");//传递null将会返回NullPointerException异常
}
public static void method(Object obj){
Object objects=Objects.requireNonNull(obj);
System.out.println(objects);
}
}
throws关键字_异常处理的第一种方式
/*
throws关键字：当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象，可以使用thorws关键字来处理异常对象，会把异常对象声明抛出给方法的调用者处理
*/
import java.io.FileNotFoundException;
public class ThrowsDemo{
public static void main(String[] args)throws FileNotFoundException{
readFile("d:\\a.txt");
}
public static void readFile(String fileName)throws FileNotFoundException{
//传递进来的文件不对就抛出异常
if(!fileName.equals("c:\\a.txt")){
throw new FileNotFoundException("传递的文件路径不对，请重新传递");
}
System.out.println("传递路径成功");
}
}
try_catch异常处理的第二种方式
捕获异常语法格式
try{
编写可能会出现异常的代码
}catch(用来接收try中抛出的异常信息 异常类型 e){
处理异常代码
}
....
catch(){}
注意：
try中可能会抛出多个异常对象，那么久可以使用多个catch来处理这些异常对象
如果try中产生了异常，那么就会执行catch中的异常处理逻辑
import java.io.FileNotFoundException;
public class ThrowsDemo1{
public static void main(String[] args){
try{
readFile("d:\\a.txt");
}catch(FileNotFoundException e){
System.out.println("传递的文件不对");
}
System.out.println("后续代码");
}
public static void readFile(String fileName)throws FileNotFoundException{
//传递进来的文件不对就抛出异常
if(!fileName.equals("c:\\a.txt")){
throw new FileNotFoundException("传递的文件路径不对，请重新传递");
}
System.out.println("路径没有问题");
}
}
Throwable类中3个异常处理的方法
getMessage() :简短的描述
toString() ：详细的消息字符串
printStackTrace()：打印的异常信息最全面
字异常符类
public class Fu{
public void show1()throws NullPointerException,ClassCastException{}
public void show2()throws IndexOutOfBoundsException{}
public void show3()throws IndexOutOfBoundsException{}
class Zi extens Fu{
//子类重写父类方法是，抛出和父类相同异常
public void show1()throws NullPointerException,ClassCastException{}
//子类重写父类方法时，抛出父类异常的子类
public void show2()throws ArrayIndexIndexOutOfBoundsException{}
//子类重写父类方法时，不抛出异常
public void show3(){}
//父类没有抛出异常，子类也不可以抛出异常，如若有异常，需要try catch处理异常
自定义异常
//自定义一个注册异常
//需要一个空参数的构造方法，一个带异常信息的构造方法
//继承Exception //那么自定义的异常类就是一个编译器异常，那就需要throws或者try...catch处理
//继承的是RuntimeException，那么异常无序处理，交给虚拟机
public class RegisterException extends Exception{
public RegisterException(){}
public RegisterException(String message){
super(message);
}
}
import java.util.*;
//使用自定义异常类
public class ExceptionDemo{
//定义一个集合，存储姓名
public static void main(String[] args){
ArrayList<String> list = new ArrayList<>();
list.add("詹姆斯");
list.add("科比");
list.add("乔丹");
list.add("诺维斯基");
list.add("邓肯");
System.out.println(list);
//让用户输入昵称
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的昵称");
String nicheng = sc.next();
//向里面添加姓名，如果不存在则添加成功，如果存在则返回注册异常
for(String name : list){
//使用字符串的方法equals判断集合是否存在元素,将会返回一个boolean
//为真，就表示昵称已经存在,需要返回一个注册异常
if(name.equals(nicheng)){
try{
throw new RegisterException("亲，该昵称已经被注册过了");
}catch(RegisterException e){
e.printStackTrace();
return;//一旦放生异常，立马结束方法
}
}
//遍历完了，如果没有发生异常，就表示昵称可以创建
}
list.add(nicheng);
System.out.println("恭喜您，注册成功");
}
}
多线程
public class ThreadDemo{
public static void main(String[] args){
MyThread mt = new MyThread();
//执行start方法，开启线程，执行run方法
//如果使用mt.run();的话程序会在堆内存中执行，那就不是多行程了，而是单线程
//每一次使用start();都会开辟一条新的线程，在栈空间里面执行run方法，多行程的好处就是线程之间互相不影响，cup喜欢哪一个线程就执行哪一个线程
mt.start();
for(int i= 0;i<10;i++){
System.out.println("main线程"+i);
}
}
}
public class MyThread extends Thread{
//重写run方法
public void run(){
for(int i=0;i<10;i++){
System.out.println("run线程"+i);
}
}
}
Thread类的常用方法
获取线程名称的方法
1.使用Thread类中的方法getName
String getName() 返回该线程的名称，那条线程调用我，我就返其的名称
2.可以先获取到当前正在执行的线程，然后使用线程中的方法getName()获取线程的名称
public class MyThread1 extends Thread{
public void run(){
/*第一种获取名字的方式
String name=getName();
System.out.println(name);*/
// 第二种获取名字的方式
//先获取当前线程(currentThread是一个静态方法，可以通过类名直接获取线程)
Thread t = Thread.currentThread();//这个方法将会返回当前的线程
//通过线程获取名字
String naem =t.getName();
System.out.println(name);
}
}
public class ThreadName{
public static void main(String[] args){
MyThread1 mt = new MyThread1();
mt.start();
}
}
设置线程名称
一种通过setName方法，一种通过构造方法来设置
public class ThreadName{
public static void main(String[] args){
MyThread1 mt = new MyThread1();
mt.setName("小强");
mt.start();
new MyThread1("旺财").start();
}
}
public class MyThread1 extends Thread{
public MyThread1(){}
public MyThread1(String name){
super(name);
}
public void run(){
/*第一种获取名字的方式
String name=getName();
System.out.println(name);*/
// 第二种获取名字的方式
//先获取当前线程
Thread t = Thread.currentThread();
//通过线程获取名字
String name =t.getName();
System.out.println(name);
}
}
sleep方法
是一个静态方法，使用类名就可以直接调用，让当前线程睡眠指定时间
创建多线程程序的第二种方式_实现Runnable接口
实现步骤：
1.创建一个Runnable接口的实现类
-
在实现类中重写Runnable接口的run方法，设置线程任务
-
创建一个Runnable接口的实现类对象
-
创建Thread类对象，构造方法中传递Runnable接口的实现类对象
-
调用Thread类的start方法，开启线程
public class RunnableImp implements Runnable{ public void run(){ for(int i=0;i<10;i++){ //获取当前的线程，然后获取线程名字 System.out.println(Thread.currentThread().getName()+"--"+i); } } }public class RunnableDemo { public static void main(String[] args){ //创建Runnable接口实现类对象 RunnableImp run = new RunnableImp(); //Thread中有个构造方法可以接Runnable接口作为参数传递 new Thread(run).start(); for(int i=0;i<10;i++){ //想要获取main方法的线程，只能够用下面的方式获取，然后获取线程名字 System.out.println(Thread.currentThread().getName()+"--"+i); } } }
