笔记-迎难而上之Java基础进阶3

发布时间:2019-05-24 06:00:01发布者:Mr.Zhang阅读(460)

统计字符串中每一个不同的字符

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方法来添加元素了

注意事项:

  1. of方法只适用于List接口,Set接口,Map接口,不适用于接口的实现类

  2. of方法的返回值是一个不能够改变的集合

  3. 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);
        }
    }
}

img

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接口的实现类

  1. 在实现类中重写Runnable接口的run方法,设置线程任务

  2. 创建一个Runnable接口的实现类对象

  3. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象

  4. 调用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);
             }
     }
    }




本文转自博客园,原文地址:https://www.cnblogs.com/train99999/p/10915569.html