Java基础知识

source:http://blog.java1234.com/index.html?typeId=1

Java关键字：

Java基本数据类型：

 

 Java基本数据类型-：

Java基本数据类型-浮点类型：

// 小数默认是double类型，所以我们必须加一个f，来表示float类型

  float f=0.1f;

输出float类型的最小值

float minF=Float.MIN_VALUE;

System.out.println("float的最小值："+minF);

Java基本数据类型-字符类型

字符型常量有3种表示形式；

1，直接通过单个字符来指定字符型常量，如'A'，‘B’，'5'；

2，通过转义字符表示特殊字符型常量，如'\n'，'\\'；

3，直接使用Unicode值来表示字符型常量，如'\u66f9'，'\u950b'；

Java基本数据类型-布尔类型

用关键字boolean定义，布尔类型只有true和false两个值； 

Java基本数据类型-基本类型的类型转换

基本类型的类型转换分为自动类型转换和强制类型转换

自动类型转换

条件：1，转换前后的数据类型兼容； 

           2，转换后的数据类型的表示范围要比转换前的大；

强制类型转换

数据类型不兼容，一种不安全的转换；

示例：

    public static void main(String[] args) {

        // 自动类型转换

        short s=1;

        int i;

        // 自动类型转换 short类型转成int类型

        i=s;

        System.out.println("i="+i);

         

        // 强制类型转换

        double d=1.333;

        float f;

        // 把double类型的数据强制转换成float类型

        f=(float)d;

        System.out.println("f="+f);

    }

Java运算符与表达式-运算符

+ (加)；

- (减)；

* (乘)；

/ (除)；

%（取模）；取模其实就是求余数

符号：++（自增）； --(自减)

重点掌握 a++ 和++a的区别 

a++是先操作后加1；

++a是先加1后操作；

Java逻辑运算符

符号：

&& 与 ：前后两个操作数必须都是true才返回true,否则返回false

& 不短路与： 表达式都会执行到

|| 或： 只要两个操作数中有一个是true，就返回true，否则返回false

| 不短路 或 ：表达式都会执行到

! 非 ：如果操作数为true，返回false，否则，返回true

^ 异或 ：当两个操作数不相同时返回true，返回false

Java关系运算符

> 大于；

< 小于；

>=大于等于；

<=小于等于；

==等于；

!=不等于；

Java三目运算符

 格式：  (表达式)?表达式为true返回值:表达式为false返回值

// 三目运算符

 String s=2>3?"表达式为真":"表达式为假";

 System.out.println(s);

Java选择语句

         

public static void main(String[] args) {
        System.out.println("请输入一个字符串：");
        Scanner scanner=new Scanner(System.in);
        String str=scanner.next();
        scanner.close();
        switch(str){
            case "张三":{
                System.out.println("输入的是张三");
                break;
            }
            case "李四":{
                System.out.println("输入的是李四");
                break;
            }
            default:{
                System.out.println("用户输入的是其他字符串");
            }
        }
    }
 public static void main(String[] args) {
        System.out.println("请输入一个数字：");
        // 定义一个系统输入对象
        // 自动导包  ctrl+shift+o
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        scanner.close();
        switch(n){
            case 1:{
                System.out.println("用户输入的是1");
                break;
            }
            case 2:{
                System.out.println("用户输入的是2");
                break;
            }
            default:{
                System.out.println("用户输入的是其他数字");
            }
        }
    }
public static void main(String[] args) {
        int a=-1;
        // if语句
        // 多行注释快捷方式  ctrl+shift+/
        if(a>0){
            System.out.println(a+"是正数");
        }
         
        // if...else语句
        if(a>0){
            System.out.println(a+"是正数");
        }else{
            System.out.println(a+"不是正数");
        }
         
        // if...else if...else
        if(a>0){
            System.out.println(a+"是正数");
        }else if(a<0){
            System.out.println(a+"是负数");
        }else{
            System.out.println(a+"是0");
        }
    }

 

Java 循环语句

while(i<=10){

    System.out.print(i+" ");

    i++;

}

do{

    System.out.print(j+" ");

    j++;

}while(j<=10);

while和do...while的区别：

while是先判断后执行 do...while是先执行后判断。

do..while是肯定会至少执行一次，while的话，不一定会执行；

 

for(int k=1;k<=10;k++){

    System.out.print(k+" ");

}

for循环有点类似while循环语句；

int k=1;定义一个变量；

k<=10是条件语句 ，满足条件就执行循环体，不满足就结束循环；

执行完循环体，再执行k++;

//九九乘法表
public static void main(String[] args) {
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+" ");
            }
            System.out.println();
        }
 }

Java循环结构的控制

循环结构的控制

 1，break语句：结束当前循环，从内层跳到外层，结束外层循环

 2，continue语句：结束当前循环；

 3，return语句：直接结束方法里的内容执行；

//求1!+2!+3!+...+10!的值
public static void main(String[] args) {
        int total=0;
        for(int i=1;i<=10;i++){
            int cTotal=1;
            for(int j=1;j<=i;j++){
                cTotal*=j;
            }
            total+=cTotal;
            System.out.println(i+"!="+cTotal);
        }
        System.out.println("1!+2!+3!+...+10!的阶乘和是："+total);
}

//求1+2+3+4...+100的和
public static void main(String[] args) {
        int total=0;
        for(int i=1;i<=100;i++){
            total+=i;
        }
        System.out.println("1+2+3+...+100的和是："+total);
}

Java数组基本概念

数组简介

数组是Java中最常见的一种数据结构，可用于存储多个数据；

数组的定义

type []arrayName; 或者 type arrayName[];

实例： int []arr ;int arr[]

数组的初始化

1,静态初始化

格式 arrayName=new type[]{element1,element2,element3...}

实例：int arr[]=new int[]{1,2,3};

2,动态初始化

格式 arrayName=new type[length];

实例：int arr2[]=new int[3]

3,数组内存分析

 

主要分为 栈区和堆区  栈区主要存放引用地址  堆区主要存放大块的实际数据，比如对象，数组；

我们可以把栈区理解成电视遥控器，堆区是电视机，我们用遥控器操作电视机总比直接操纵电视机方便，所以这个就是栈区的意义；栈区里的引用地址指向堆区的具体数据；

二维数组及多维数组

二维数组静态初始化 格式：

arrayName=new type[]{{element1,element2},{element1,element2},{element1,element2}};

实例：int [][]arr=new int[][]{{1,2,3},{4,5,6},{7,8,9}};

二维数组动态初始化 格式：

arrayName=new type[length][length];

实例：int [][]arr2=new int[3][3];

二维数组的内存分析：

数组排序实例-起泡法

对 4,21,0,-12,-3排序 升序

 

起泡法是从一端开始比较的，第一次循环就是把最大数放到最后一个位置，第二次循环就是把第二最大数放到倒数第二位置。整个过程就像烧开水一样，较小值像水中的气泡一样逐趟往上冒，每一趟都有一块“最大”的石头沉到水底。

	4	21	0	-12	-3
第一次	4	0	-12	-3	21
第二次	0	-12	-3	4	21
第三次	-12	-3	0	4	21
第四次	-12	-3	0	4	21

 

具体思路  5个数字，我们外层遍历四次即可 每次遍历 相邻的数字比较，我们把最大的数字沉入到底部。第一次遍历，我们能够实现把最大的数字沉到最底部；

第二次遍历，我们能把第二大数字沉到倒数第二个位置；依次类推，最终我们实现从小到大排序；

public static void main(String[] args) {
        int arr[]={4,21,0,-12,-3};
        int temp;
        // 循环次数 n-1次
        for(int i=0;i<arr.length-1;i++){
            // 比较次数 n-1-i
            for(int j=0;j<arr.length-1-i;j++){
                // 假如前面一个数大于后面一个数，则交换数据
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }  
            }
        }
        for(int a:arr){
            System.out.print(a+" ");
        }
}

//获取数组中的最大值和最小值
public static void main(String[] args) {
        int arr[]=new int[]{1,6,21,7,-2}; // 定义一个数组
        int max=arr[0]; // 把数据中的第1个元素存max
        int min=arr[0]; // 把数据中的第1个元素存min
        for(int i=1;i<arr.length;i++){ // 从第二个元素开始遍历数组
            if(arr[i]>max){  // 假如元素大于max 就把当前值赋值给max
                max=arr[i];
            }
            if(arr[i]<min){  // 假如元素小于min 就把当前值赋值给min
                min=arr[i];
            }
        }
        System.out.println("数组中的最大值："+max);
        System.out.println("数组中的最小值："+min);
 }

//定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数
public static void main(String[] args) {
        int arr[]=new int[]{1,6,21,7,-2,9,0,81}; // 定义一个数组
        int jishu=0; // 用来统计奇数个数
        int oushu=0; // 用来统计偶数个数
        for(int i=0;i<arr.length;i++){ // 遍历数组
            if(arr[i]%2==1){  // 假如求余余数是1 就是奇数
                jishu++; // 奇数个数加1
            }
            if(arr[i]%2==0){  // 假如求余余数是0 就是偶数
                oushu++;
            }
        }
        System.out.println("数组中的奇数个数："+jishu);
        System.out.println("数组中的偶数个数："+oushu);    
}

//数组去掉0，把非0元素存新数组
public static void main(String[] args) {
        int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
        int zero=0; // 统计0的个数
        for(int i=0;i<oldArr.length;i++){
            if(oldArr[i]==0){
                zero++;
            }
        }
        int newArr[]=new int[oldArr.length-zero]; // 定义新的数组 长度是 原来旧的数组的长度减去0的个数
        int j=0; // 新数组的索引
        for(int i=0;i<oldArr.length;i++){ // 遍历原来旧的数组
            if(oldArr[i]!=0){ // 假如不等于0
                newArr[j]=oldArr[i]; // 赋值给新的数组
                j++;
            }
        }
         
        System.out.print("新数组：");
        for(int n:newArr){
            System.out.print(n+" ");
        }
}