Java基础知识练习

       int a = 1;

       String b = "2";

       String c = "3";

       System.out.println(a+b+c);

输出结果：123
原因：因为“a+b+c”中的加号是连接符，会将a的数据类型转变为字符串类型

      float f1 = 9.9f;

      float f2 = 0.1f;

      System.out.println(f1 - f2);

输出结果：9.799999
原因：结果本应该是9.8，但是由于0.8在计算机中无法用二进制表示，这说明并非所有小数都能够在计算机中被精准的表示出来

1.假设王者荣耀的等级规则如下： 0～100：倔强青铜 101～500：秩序白银； 501～2000：荣耀黄金； 2001～5000：尊贵铂金； 5001～10000：永恒钻石； 10001～20000：至尊黑曜；20000 以上：最强王者； 玩家 A 积分 1760，玩家 B 积分 9527，玩家 C 积分 16800。 用 if 条件分支计算玩家积分，判断该玩家 A、玩家 B 和玩家 C 都是什么等级。

public class Main {

    public static void main(String[] args) {
        System.out.println("玩家A的等级为：" + degreeJudge(1760));
        System.out.println("玩家B的等级为：" + degreeJudge(9527));
        System.out.println("玩家C的等级为：" + degreeJudge(16800));
    }

    static String degreeJudge(int degree) {
        if(degree<0) {
            return "输入错误";
        }else if(degree>=0 && degree<=100) {
            return "倔强青铜";
        }else if(degree>=101 && degree<=500) {
            return "秩序白银";
        }else if(degree>=501 && degree<=2000) {
            return "荣耀黄金";
        }else if(degree>=2001 && degree<=5000) {
            return "尊贵铂金";
        }else if(degree>=5001 && degree<=10000) {
            return "永恒钻石";
        }else if(degree>=10001 && degree<=20000) {
            return "至尊黑曜";
        }else {
            return "最强王者";
        }
    }
}

2.下列代码执行完y的结果是多少？

        int y = 0;
        do {
            y++;
        }while(y<0);
        System.out.println("y = " + y);

执行结果：y=1，因为do-while循环至少会执行一次，且一次之后不满足y<0的条件，那么退出循环

3.用多种循环结构计算并打印出 100 的阶乘（for、while、do…while）

    public static void main(String[] args) {
        double sum = 1 ;
        for(int i=1 ; i<=100 ; i++) {
            sum = i * sum;
        }
        System.out.println(sum);
    }

    public static void main(String[] args) {
        double sum = 1 ;
        int i = 1;
        while(i<101){
            sum *= i;
            i++;
        }
        System.out.println(sum);
    }

    public static void main(String[] args) {
        double sum = 1 ;
        int i = 1;
        do{
            sum *= i;
            i++;
        }while(i<101);
        System.out.println(sum);
    }

4.用递归实现以下问题

计算斐波那契数列之和(N=50)

public class Main {

    public static void main(String[] args) {
        System.out.println(F(50));
    }

    static int F(int n) {
        if(n == 1 || n == 2)
            return 1;
        else {
            return F(n-1)+F(n-2);
        }
    }
}

计算10的阶乘

public class Main {

    public static void main(String[] args) {
        System.out.println(F(10));
    }

    static int F(int n) {
        if(n == 1)
            return 1;
        else
            return n*F(n-1);
    }
}

对数组[8, 2, 11, 9, 1, 5, 3]使用二分算法进行排序

public class Main {

    public static void main(String[] args) {
        int[] A = {8, 2, 11, 9, 1, 5, 3};
        int low,high,target;
        for (int i = 1; i < A.length; i++) {
            low = 0;
            high = i-1;
            target = A[i];
            low = BinarySort(A,low,high,target);
            for(int j = i-1 ; j >= low ; j--)
                A[j+1] = A[j];
            A[low] = target;
        }
        for (int i = 0; i < A.length; i++)
            System.out.print(A[i] + " ");
    }

    static int BinarySort(int A[], int low, int high, int target) {
        int mid = (low + high) / 2;
        if (low > high)
            return low;
        else {
            if (target >= A[mid])
                return BinarySort(A, mid + 1, high, target);
            else
                return BinarySort(A, low, mid - 1, target);
        }
    }
}

和数分解：把一个数分解成任意几个数的和，并把所有的可能性都列出来

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] A = new int[50];
        for(int i = 0 ; i < 50 ; i++)
            A[i] = 1;
        A[1] = n;
        seperate(A,1);
    }

   static void print(int A[] , int k) {
        for(int i=1 ; i <= k ; i++){
            System.out.print(A[i] + "+");
        }
        System.out.println(A[k+1]);
   }

   static void seperate(int A[],int k){
        //对A[k]进行拆分
       int temp = A[k];
       //为了避免重复，拆分出来的数小于等于目标数的一半
       for(int i = A[k-1] ; i <= temp/2 ; i++){
            A[k] = i;
            A[k+1] = temp-i;
            print(A,k);
            seperate(A,k+1);
       }
   }
}

用递归打印树形结构

public class Main {

    public static void main(String[] args) {
        Node node1 = new Node("中国");
        Node node2 = node1.addChild(new Node("北京市"));
        Node node3 = node2.addChild(new Node("朝阳区"));
        Node node4 = node2.addChild(new Node("海淀区"));
        Node node5 = node1.addChild(new Node("湖北省"));
        Node node6 = node5.addChild(new Node("武汉市"));
        Node node7 = node6.addChild(new Node("江汉区"));
        Node node8 = node6.addChild(new Node("江夏区"));
        Node node9 = node1.addChild(new Node("湖南省"));
        Node node10 = node9.addChild(new Node("长沙市"));
        Node node11 = node9.addChild(new Node("郴州市"));
        Node node12 = new Node("美国");
        Node node13 = node12.addChild(new Node("加利福尼亚州"));
        Node node14 = node12.addChild(new Node("得克萨斯州"));
        print(node1,0);
        print(node12,0);
    }

    public static class Node {
        private String data = "";
        private List children = new ArrayList<>();
        private Node parent = null;

        public Node(String data){
            this.data = data;
        }

        public Node addChild(Node child){
            child.setParent(this);
            this.children.add(child);
            return child;
        }

        public String getData() {
            return data;
        }

        public Node getParent() {
            return parent;
        }

        public void setData(String data) {
            this.data = data;
        }

        public void setParent(Node parent) {
            this.parent = parent;
        }

        public List getChildren(){
            return children;
        }
    }
//递归打印结点
    public static void print(Node node , int level){
        for(int i = 0 ; i < level ; i++)
            System.out.print("    ");
        System.out.println("·" + node.getData());
        for(Node node1 : node.getChildren()){
            print(node1,level+1);
        }
    }

}

回调：顾名思义，就是返回后再调用，这是一种编程模式或机制，它不同于一般的阻塞式调用， 不需要等待被调用方执行完毕才能返回。它在发起调用后就能立即返回，继续执行后续任务， 当被调用方执行完毕后可以通过调用方的接口方法来通知它获取结果。例如，小明到商店买 东西，刚好他要的东西没有货，于是小明在店员那里留下了自己的电话就回去了。过了几天 店里有货了，店员给小明打电话通知他来买，小明接到电话后就到店里去买了他所需要的东 西。在这个例子中，小明就是发起调用方，店员就是被调用方。

在实际开发中，经常需要用到一些周期性的操作，那么就可以用Timer定时器来完成相应操作：

schedule(TimerTask task, Date time) :    安排在 "指定的时间" 执行 指定的任务。（只执行一次）

schedule(TimerTask task, Date firstTime , long period) :    安排指定的任务在 "指定的时间 " 开始进行 "重复" 的固定延迟执行

schedule(TimerTask task,long delay) :      安排在指定延迟后执行指定的任务．

schedule(TimerTask task,long delay,long period):    安排指定的任务指定的延迟后开始进行重复的固定延迟执行．

scheduleAtFixedRate(TimerTask task,Date firstTime,long period):    安排指定的任务在指定的时间开始进行重复的固定速率执行．

scheduleAtFixedRate(TimerTask task,long delay,long period):    安排指定的任务在指定的延迟后开始进行重复的固定速率执行．

Timer.cancal():    终止此计时器，丢弃所有当前已安排的任务。

Timer.purge():    从此计时器的任务队列中移除所有已取消的任务。

用回调函数实现：张伟在超市买了一瓶快乐水和一些吃的，使用支付 APP 完成支付后，过了几秒，APP 通知他已经支付成功。
可以利用schedule(TimerTask task,long delay) : 安排在指定延迟后执行指定的任务来实现

package com.company;

import com.sun.org.apache.xpath.internal.FoundIndex;

import java.util.*;

public class Main {

    public static void main(String[] args) {
        System.out.println("请输入支付密码：");
        Scanner scanner = new Scanner(System.in);
        String code = scanner.next();
        if(code.equals("000000"))
            delay(true);
        else
            delay(false);
    }

    public static void delay(boolean code) {
        Timer timer = new Timer();
        //如果输入密码正确
        if(code) {
            timer.schedule(new TimerTask(){
                public void run(){
                    System.out.println("支付成功");
                    this.cancel();
                }
            },3000);
        }else {
            //密码输入错误
            timer.schedule(new TimerTask(){
                public void run(){
                    System.out.println("密码输入错误");
                    this.cancel();
                }
            },3000);
        }
    }

}

用回调函数实现：李雷周一在某某宝 APP 上买了两张周五晚上的电影票。在周五晚上电影即将放映的前 一小时，APP 给他发来了观影通知
可以schedule(TimerTask task, Date time) : 安排在 “指定的时间” 执行 指定的任务。（只执行一次）来实现操作

package com.company;

import java.util.*;
import java.util.concurrent.CancellationException;

public class callback {

    public static void main(String[] args) {
        delay();
    }

    public static void delay(){
        //设置时间
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY,16);
        calendar.set(Calendar.MINUTE,53);
        calendar.set(Calendar.SECOND,0);
        Date time = calendar.getTime();
        System.out.println(time);
        Timer timer = new Timer();
        timer.schedule(new TimerTask(){
            public void run(){
                System.out.println("电影于一小时后开始，请您注意时间");
            }
        },time);
    }
}

韩梅梅周末在家休息，她把衣服丢到洗衣机里之后就去扫地、做饭去了，过了一会，洗 衣机就「嘀～嘀～」响几声通知她衣服已经洗好了。
用schedule(TimerTask task,long delay,long period): 安排指定的任务指定的延迟后开始进行重复的固定延迟执行实现

package com.company;

import com.sun.org.apache.xpath.internal.FoundIndex;

import java.util.*;

public class Main {

    public static void main(String[] args) {
        delay();
    }

    public static void delay() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("滴滴滴 滴滴滴");
            }
        },10*60*1000,60*1000);//假设10分钟洗好衣服，每1分钟提示一次
    }

}

打印菜单：要求： 1）、已选择的序号不能再重复选择，并给出提示 2）、输入全部序号后显示全部菜名和总价并自动退出终端 3）、使用标准输入和 Scanner 两种方式实现输入

package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class dishes {
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        Menu menu = new Menu();
        //制作菜单
        for(int i = 1 ; i <= 5 ; i++){
            System.out.println("请输入菜品和价钱");
            String name = scanner.next();
            int price = scanner.nextInt();
            Dish dish = new Dish(i,name,price);
            menu.addDish(dish);
        }
        //打印菜单
        menu.printMenu();
        int temp = 0;//表示已选菜品
        int totalPrice = 0;
        while(temp!=5&&temp!=6){
            System.out.println("请选择菜品，输入6表示点单完毕");
            int number = scanner.nextInt();
            if(number == 6)
                temp = 6;
            else{
                for(Dish dish : menu.getItems()){
                    if(dish.getNumber() == number) {
                        if(dish.isSelected()==true){
                            System.out.println("对不起，您已点过这个菜");
                        }else{
                            temp++;
                            dish.setSelected(true);
                            totalPrice+=dish.getPrice();
                        }
                    }
                }
                System.out.print("已选：");
                for(Dish dish : menu.getItems()){
                    if(dish.isSelected() == true)
                        System.out.print(dish.getName()+" ");
                }
                System.out.println();
                System.out.println("总价："+totalPrice);
            }

        }
    }
}

class Dish {
    private int number;
    private String name;
    private int price;
    private boolean selected = false;

    public Dish() {
    }

    public Dish(int number, String name, int price) {
        this.number = number;
        this.name = name;
        this.price = price;
    }

    public int getNumber() {
        return number;
    }

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

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public boolean isSelected() {
        return selected;
    }

    public void setSelected(boolean selected) {
        this.selected = selected;
    }
}

class Menu {
    private List items = new ArrayList();

    public Menu() {
    }

    //打印菜单
    public void printMenu(){
        for(Dish item:items){
            System.out.println(item.getNumber()+"."+item.getName()+"   "+item.getPrice()+"元" );
        }
    }

    //加入菜肴
    public void addDish(Dish dish){
        items.add(dish);
    }

    public List getItems() {
        return items;
    }
}

打印多级列表：

package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class printTest {
    static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args){
        Node node = new Node(0,"parent");
        Node node1 = node.addNode(new Node(1,"中国"));
        Node node2 = node1.addNode(new Node(1,"北京"));
        Node node3 = node1.addNode(new Node(2,"湖北"));
        Node node4 = node1.addNode(new Node(3,"湖南"));
        Node node5 = node2.addNode(new Node(1,"朝阳区"));
        Node node6 = node2.addNode(new Node(2,"海淀区"));
        Node node7 = node2.addNode(new Node(3,"昌平区"));
        Node node8 = node3.addNode(new Node(1,"武汉市"));
        Node node9 = node3.addNode(new Node(2,"襄樊市"));
        Node node10 = node3.addNode(new Node(3,"咸宁市"));
        Node node11 = node4.addNode(new Node(1,"长沙市"));
        Node node12 = node4.addNode(new Node(2,"株洲市"));
        Node node13 = node4.addNode(new Node(3,"湘潭市"));

        Node node14 = node.addNode(new Node(2,"美国"));
        Node node15 = node14.addNode(new Node(1,"纽约州"));
        Node node16 = node14.addNode(new Node(2,"得克萨斯"));
        Node node17 = node14.addNode(new Node(3,"加利福尼亚"));
        Node node18 = node15.addNode(new Node(1,"曼哈顿"));
        Node node19 = node15.addNode(new Node(2,"布鲁克林"));
        Node node20 = node15.addNode(new Node(3,"皇后区"));
        Node node21 = node16.addNode(new Node(1,"奥斯汀"));
        Node node22 = node16.addNode(new Node(2,"休斯顿"));
        Node node23 = node16.addNode(new Node(3,"达拉斯"));
        Node node24 = node17.addNode(new Node(1,"洛杉矶"));
        Node node25 = node17.addNode(new Node(2,"旧金山"));
        Node node26 = node17.addNode(new Node(3,"奥克兰"));

        printAll(node1,0);
        printAll(node14,0);
        select(node);

    }

    public static class Node {
        private int number;
        private String data;
        private List children = new ArrayList();

        public Node(int number, String data) {
            this.number = number;
            this.data = data;
        }

        //添加子结点
        public Node addNode(Node node) {
            children.add(node);
            return node;
        }

        public int getNumber() {
            return number;
        }

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

        public String getData() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }

        public List getChildren() {
            return children;
        }

        public void setChildren(List children) {
            this.children = children;
        }

    }



    //打印菜单
    public static void printAll(Node node , int level){
        for(int i = 0 ; i < level ; i++)
            System.out.print("   ");
        System.out.println(node.getNumber()+"."+node.getData());
        for(Node node1 : node.getChildren())
            printAll(node1,level+1);
    }

    public static boolean select(Node node){
        if(node == null)
            return false;
        else{
            System.out.println("请选择序号：");
            int number = scanner.nextInt();
            for(Node node1 : node.getChildren()){
                if(node1.getNumber() == number){
                    if(node1.getChildren().size()!=0) {
                        for (Node node2 : node1.getChildren()) {
                            System.out.println(node2.getNumber() + "." + node2.getData());
                        }
                        select(node1);
                    }else{
                        System.out.println(node1.getNumber()+"."+node1.getData());
                        return false;
                    }
                }
            }
        }
        return false;
    }
}