JavaSE-基本程序设计结构（下）

Posted 2021-07-04 Jack·Kwok

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE-基本程序设计结构（下）相关的知识，希望对你有一定的参考价值。

JavaSE-基本程序设计结构（下）

1. 输入与输出
2.控制流程
3.大数
4.数组

1. 输入与输出

1.1. 读取和输出

输出：将内容输出到控制台窗口

 System.out.println("hello world");

读取：

import java.util.Scanner;

public class Me {
    public static void main(String[] args) {
        //创建一个Scanner对象
        Scanner scanner = new Scanner(System.in);
        //读取一行
        String s = scanner.nextLine();
        //读取一个单词（以分隔符为界）
        String next = scanner.next();
        //读取一个整型数据
        int i = scanner.nextInt();
        //读取一个浮点型数据
        double v = scanner.nextDouble();
    }

PS：当我们使用的类不是在java.lang包里面的时，需要导入包，如第一句中导入Scanner类。

1.2. 格式化输出

public class Me {
    public static void main(String[] args) {
        double d = 23.456;
        System.out.println(d);
        System.out.printf("%5.2f",d);
    }
}

“%5.2f”:其中的2表示保留小数点后两位，5表示总共显示5位（包括小数点），如果不够，在前面补空格。

1.3. 文件的输入输出

FileInputStream：字节流、输入 
FileOutputStream：字节流、输出
FileReader ：字符流、输入
FileWriter：字符流、输入

文本文件用字节流或字符流读写（考虑到中文等因素，优先考虑字符流）
非文本文件只能用字节流读写

FileInputStream 读取文件：

FileInputStream fis=null;
      try {
          //创建字节输入流
          fis=new FileInputStream("E:\\\\learnproject\\\\Iotest\\\\lib\\\\src\\\\main\\\\java\\\\com\\\\Test.txt");
          //创建一个长度为1024的竹筒
          byte[] b=new byte[1024];
          //用于保存的实际字节数
          int hasRead=0;
          //使用循环来重复取水的过程
          while((hasRead=fis.read(b))>0){
              //取出竹筒中的水滴（字节），将字节数组转换成字符串进行输出
            System.out.print(new String(b,0,hasRead));
          }
      }catch (IOException e){
        e.printStackTrace();
      }finally {
          fis.close();
      }

FileOnputStream 写入文件：

 FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建字节输入流
            fis=new FileInputStream("E:\\\\learnproject\\\\Iotest\\\\lib\\\\src\\\\main\\\\java\\\\com\\\\Test.txt");
            //创建字节输出流
            fos=new FileOutputStream("E:\\\\learnproject\\\\Iotest\\\\lib\\\\src\\\\main\\\\java\\\\com\\\\newTest.txt");

            byte[] b=new byte[1024];
            int hasRead=0;

            //循环从输入流中取出数据
            while((hasRead=fis.read(b))>0){
                //每读取一次，即写入文件输入流，读了多少，就写多少。
                fos.write(b,0,hasRead);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            fis.close();
            fos.close();
        }

FileReader 读取文件：

FileReader fis=null;
        try {
            //创建字节输入流
            fis=new FileReader("E:\\\\learnproject\\\\Iotest\\\\lib\\\\src\\\\main\\\\java\\\\com\\\\Test.txt");
            //创建一个长度为1024的竹筒
            char[] b=new char[1024];
            //用于保存的实际字节数
            int hasRead=0;
            //使用循环来重复取水的过程
            while((hasRead=fis.read(b))>0){
                //取出竹筒中的水滴（字节），将字节数组转换成字符串进行输出
                System.out.print(new String(b,0,hasRead));
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            fis.close();
        }

2.控制流程

2.1. 条件语句

if(条件){
    要执行的代码
}

if(条件){
	要执行的代码
}else if(){
    要执行的代码
}else{
    要执行的代码
}

2.2. 循环语句

2.2.1. while语句

while(条件){
    要执行的代码 
}

2.2.2. do-while语句

do{
     要执行的代码       
}while ();

2.2.3. for语句

public class Me {
    public static void main(String[] args) {
        int[] ints = {2,5,7,5,4,7,4};
        for (int i = 0 ;i < ints.length;i++){
            System.out.print(ints[i]+" ");
        }
    }
}

2.2.4. switch语句

public class Me {
    public static void main(String[] args) {
        int a = 2+4;
        switch (a){
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            case 6:
                System.out.println("ok");
                break;
            default:
                System.out.println("not thinking");
                break;
        }
    }
}

2.3. 中断控制流程语句

break:    跳出最近一层的循环
continue：跳出最近一层的循环的这次循环

3.大数

如果基本数据类型的整数和浮点数精度不能满足要求时，那么可以使用java中的math包的BigInteger和BigDecimal类。这里以前者为例：

public class Me {
    public static void main(String[] args) {
        //通过BigInteger的valueOf这个静态方法创建
        BigInteger a = BigInteger.valueOf(100);
        System.out.println(a);
        //通过闯将BigInter实例化对象，然后通过构造器创建
        BigInteger big = new BigInteger("12345678987654321");
        System.out.println(big);
        //大数运算不能使用加减乘除等运算符，而是应该如下：
        BigInteger bb = BigInteger.valueOf(2);
        BigInteger bb1 = BigInteger.valueOf(4);
        //加法
        BigInteger cc = bb.add(bb1);
        System.out.println(cc);
        //乘法
        BigInteger kk = bb.multiply(bb1);
        System.out.println(kk);
        //减法
        BigInteger jj = bb.subtract(bb1);
        System.out.println(jj);
        //除法
        BigInteger ccc = bb.divide(bb1);
        System.out.println(ccc);
        //余数
        BigInteger ys = bb.mod(bb1);
        System.out.println(ys);
    }
}

4.数组

4.1. 声明数组

创建数组的三种方式
int[] a;
int[] b = new int[10];
int[] c = {1,4,7,2};

4.2. 访问数组元素

public class Me {
    public static void main(String[] args) {
        int[] aa = {2,4,6,7,8};
        //1.遍历数组方式一
        for (int a :aa){
            System.out.println(a);
        }
        //2.遍历数组方式二
        for(int i = 0;i<aa.length;i++){
            System.out.println(aa[i]);
        }
    }
}

4.3. 数组的拷贝

数组的一个元素拷贝：

public static void main(String[] args) {
        int[] aa = new int[3];
        aa[1] = 5;
        int[] bb = aa;
        System.out.println(bb[1]);
    }

整个数组拷贝，经常用来扩充数组

public class Me {
    public static void main(String[] args) {
        int[] lucc = {2,4,2,3,3};
        int[] ints = Arrays.copyOf(lucc, 2 * lucc.length);
        System.out.println(ints);
    }
}

数组排序

public class Me {
    public static void main(String[] args) {
        int[] lucc = {2,4,2,3,3};
        Arrays.sort(lucc);
        System.out.println(lucc);
        System.out.println(lucc.toString());
    }
}

以上是关于JavaSE-基本程序设计结构（下）的主要内容，如果未能解决你的问题，请参考以下文章

[javaSE] 数据结构（AVL树基本概念）