Java经典编程(基础篇)

1.
package base.java.example;
/**
 *  输出hello world
 */
public class HeloWorld {
    public static void main(String args[]){
        System.out.println("hello world");
    }
}

2.
package base.java.example;
/**
 * 打印输出符号表情
 * 
 */
public class FuHaoBiaoQing {
    public static void main(String[] args){
        System.out.println("                 ╭︿︿︿╮ ");  
        System.out.println("   {/ o  o /}");  
        System.out.println("    ( (oo) )");  
        System.out.println("                    ︶ ︶︶");  
    }
}

3.
package base.java.example;
import java.util.Scanner;
/**
 *控制台输入输出 
 *说明：Scanner sc = new Scanner(System.in);
 *通过new Scanner(System.in)创建一个Scanner,控制台会一直等待输入，直到敲回车结束
 *把所输入的内容传给Scanner，作为扫描对象
 *要获取输入的内容，则只需要调用Scanner的nextLine、next、nextInt等方法
 */
public class ConsoleInput {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符");
        String line = sc.nextLine();
        System.out.println("你输入的字符串是"+line);
    }
}

4.
package base.java.example;
/**
 * 打印输出*组成的三角
 * 
 */
public class xingsanjiao {
    public static void main(String args[]){
        baseSJ();
        forSJ();
        forZZSJ();
        forDSJ();
        forDZSJ();
    }

    //普通方法打印三角
    public static void baseSJ(){
        System.out.println("     *     ");
        System.out.println("    * *    ");
        System.out.println("   * * *   ");
        System.out.println("  * * * *  ");
        System.out.println(" * * * * * ");
        System.out.println("* * * * * *");
    }
    //for循环遍历打印三角
    //将图形分成两块，倒直角空白三角形  与  *组成的正三角形
    public static void forSJ(){
        //第一层for循环遍历行数(总共有多少行)
        for(int i = 0 ; i < 6; i++){
            //打印空白三角形每一行的空格的数量
            //(6-i-1)控制空白三角形的距离控制台左边的位置
            for(int m = 0 ; m < 6 - i - 1 ; m++){
                System.out.print(" ");
            }
            //打印*三角形
            for(int n = 0 ; n <= i ; n++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
    //for循环打印倒三角
    //将图形分成两块，正直角空白三角形  与  *组成的倒三角形
    public static void forDSJ(){
        //第一层for循环遍历行数(总共有多少行)
        for(int i = 0 ; i < 6; i++){
            //打印空白三角形每一行的空格的数量
            //(6-i)控制空白三角形的距离控制台左边的位置
            for(int m = 6 ; m > 6 - i  ; m--){
                System.out.print(" ");
            }
            //打印倒*三角形
            for(int n = 6 ; n > i ; n--){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
    //打印正直角三角形
    public static void forZZSJ(){
        //第一层for循环遍历行数
        for(int i = 0 ; i < 6 ; i++){
            //第二层for循环遍历列数
            for(int j = 0 ; j <= i ; j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    //打印倒直角三角形
        public static void forDZSJ(){
            //第一层for循环遍历行数
            for(int i = 0 ; i < 6 ; i++){
                //第二层for循环遍历列数
                for(int j = 6 ; j > i ; j--){
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
}

5.
package base.java.example;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
 * 重定向输出流实现程序日志
 * 说明：System类中的out成员变量是Java的标准输出流，程序常用它来输出调试信息
 * out成员被定义为final类型的，无法直接重新复制，但是可以通过setOut()方法来
 * 设置新的输出流。本案例利用该方法实现了输出流的重定向。把它指向一个文件输出流，
 * 从而实现了日志功能。
 * 程序结束后，控制台提示运行结束信息，但是在执行过程中的步骤都保存到了日志文件中
 */
public class RedirectStream {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            PrintStream out = System.out;
            PrintStream ps = new PrintStream("D://log.txt");
            System.setOut(ps);
            int age = 18;
            System.out.println("年龄变量成功定义，初始值为18");
            String sex = "女";
            System.out.println("性别变量成功定义，初始值为女");
            //整合两个变量
            String info = "这是个"+sex+"孩子,应该有"+age+"岁了。";
            System.out.println("整合两个变量为info字符串变量，其结果是："+info);
            //恢复到原有输出流
            System.setOut(out);
            System.out.println("程序运行完毕，请查看日志文件");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}
/**
 * 本实例的关键技术是调用了System类的setOut()方法改变了输出流，System类的out、err和in成员变量地final
 * 类型的，不能直接赋值，要通过相应的方法来改变流。
 * 1.setOut()方法
 * 该方法用于重新分配System类的标准输出流。
 * 方法的声明：
 * public static void setOut(PrintStream out)
 * 参数说明：
 * out：新的PrintStream输出流对象
 * 2.setErr()方法
 * 该方法将重新分配System类的标准错误输出流
 * 方法的声明：
 * public static void setErr(PrintStream err)
 * 参数说明：
 * err：新的PrintStream输出流对象
 * 3.setIn()方法
 * 该方法将重新设置System类的in成员变量，即标准的输入流
 * 方法的声明：
 * public static void setIn(PrintStream in)
 * 参数说明：
 * in:新的InputStream输入流对象
 * 
 */

6.
package base.java.example;
/**
 *基本数据类型之间的转换
 *boolean类型不能转换成任何其他基本数据类型
 *自动类型转换：取值范围小的转换成取值范围大的
 *1)byte,short,int--->long--->float--->double
 *2)char--->int--->long--->float--->double
 *short,char不会相互转换
 *byte,short,char三者在计算时会转换成int类型
 *强制类型转换：数据类型取值范围大的转换为取值范围小的。需要加强制转换符，也就是(要转换的数据类型)
 *强制类型转换有可能造成精度降低或者数据溢出，使用时要谨慎
 * 
 */
public class TypeExchange {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int b = 127;
        char c = 'W';
        short s = 23561;
        int i = 3333;
        long l = 400000L;
        float f = 3.14159F;
        double d = 54.523;
        //低类型向高类型自动转换
        System.out.println("累加byte等于"+b);
        System.out.println("累加char等于"+(b+c));
        System.out.println("累加short等于"+(b+c+s));
        System.out.println("累加int等于"+(b+c+s+i));
        System.out.println("累加long等于"+(b+c+s+i+l));
        System.out.println("累加float等于"+(b+c+s+i+l+f));
        System.out.println("累加double等于"+(b+c+s+i+l+f+d));
        //高类型向低类型的强制转换
        System.out.println("把long强制类型转换为int："+(int)l);
        //高类型向低类型转换会丢失数据
        System.out.println("把long强制类型转换为short："+(short)l);
        //实数到整数转换将舍弃小数部分
        System.out.println("把double强制类型转换为int："+(int)d);
        //整数到字符型的转换将获取对应编码的字符
        System.out.println("把short强制类型转换为char："+(char)s);
    }
}

7.
package base.java.example;
import java.util.Scanner;
/**
 * 通过位运算的亦或运算符"^"把字符串与一个指定的值进行亦或运算，从而改变字符串中每个字符的值。
 * 这样就可以得到一个加密后的字符串。
 * 当把加密后的字符串作为程序输入内容，亦或运算会把加密后的字符串还原为原来的字符串
 * 
 */
public class OrEncryption {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个英文字符串或者解密字符串");
        //获取用户输入
        String password = sc.nextLine();
        //获取字符数组
        char[] array = password.toCharArray();
        //遍历字符数组
        for(int i = 0 ; i < array.length ; i++){
            array[i] = (char) (array[i]^20000);
        }
        System.out.println("加密或解密结果如下：");
        //输出秘钥
        System.out.println(new String(array));
    }
}

8.
package base.java.example;
import java.util.Scanner;
/**
 * 三元运算符是if...else条件语句的简写格式，它可以完成简单的条件判断。
 * 此程序要求用户输入一个整数，然后程序判断是奇数还是偶数，并输出到控制台中
 * 思路：
 * 判断是否是2的倍数即  x/2==0 ? "偶数":"奇数"
 * 
 */
public class SYYSFJO {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建输入流扫描器
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        //获取用户输入的整数
        long number = sc.nextLong();
        String check = (number % 2 == 0) ? "这个数字是：偶数" : "这个数字是：奇数";
        System.out.println(check);
    }
}

9.
package base.java.example;
import java.util.Scanner;
/**
 *程序开发中常用的乘法运算是通过"*"运算符或者BigDecimal类的multiply()方法来实现的。
 *乘法运算效率比较高的运算方式为位移运算，即左移右移。2*16相当于 2左移四位
 *一个数左移n位，就相当于这个整数乘以2的n次方
 *例如：2<<4 (即2左移4位)相当于2的4次方，也就是16 
 */
public class ShiftArithmetic {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        //获取输入的整数
        long number = sc.nextLong();
        System.out.println("你输入的数字是："+number);
        System.out.println("该数字乘以2的运算结果是："+(number<<1));
        System.out.println("该数字乘以4的运算结果是："+(number<<2));
        System.out.println("该数字乘以8的运算结果是："+(number<<3));
        System.out.println("该数字乘以16的运算结果是："+(number<<4));
    }
}

10.
package base.java.example;
import java.util.Scanner;
/**
 *变量的互换常见于数组排序算法中，当判断两个数组元素需要交互时，将创建一个临时变量来共同完成交互。
 *临时变量的创建增加了系统的消耗，如果需要交换的是两个整数类型的变量，那么可以使用更高效的方法。
 *本例使用了亦或运算来实现两个整数类型变量的互换 
 * 
 */
public class ExchangeVariable {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入变量A的值");
        //接受第一个变量的值
        long A = sc.nextLong();
        System.out.println("请输入变量B的值");
        //接受第二个变量的值
        long B = sc.nextLong();
        System.out.println("A="+A+"\tB="+B);
        System.out.println("执行变量互换...");
        A = A^B;
        B = B^A;
        A = A^B;
        System.out.println("A="+A+"\tB="+B);
    }
}