Java.基础(学习笔记)
Java.基础(学习笔记)
黑武士 发表于3年前
Java.基础(学习笔记)
  • 发表于 3年前
  • 阅读 34
  • 收藏 3
  • 点赞 0
  • 评论 0

标题:腾讯云 新注册用户域名抢购1元起>>>   

摘要: Java基础
/*
1 标识符
    1.1. 在程序中所定义的一些名称,由26个英文字母大小写,数字0-9,符号:_$组成
    1.2 定义合法的标识符规则:
        a.数字不可以开头
        b.不可以使用关键字
        c.Java中严格区分大小写,在起名字时,为了提高阅读性,尽量起有意义的名字。
 
2 常量与变量
    2.1 常量:常量表示不能改变的数值
    2.2. Java中的常量分类:
        a.整数常量。所有整数
        b.小数常量。所有小数
        c.布尔型常量。较为特有,只有2个数值。true false
        d.字符常量。将一个数字字母或者符号用单引号(‘’)标识。
        e.字符串常量。将一个数字字母或者符号用双引号(“”)标识。
        f.null常量。只有一个数值就是null
        g.对于整数Java有三种表现形式:
            a)十进制:0-9满10进1。
            b)八进制:0-7满8进1,用0开头表示。
            c)十六进制:0-9,A-F,满16进1,用0x表示。
3 进制转换
    a.十进制转二进制:  原理:对十进制数进行除2运算  
    b.二进制转十进制:  原理:二进制乘以2的过程        
    c.转八进制:     原理:先转换成二进制,在转成八进制,3个代表一位 
    d.转十六进制:        原理:先转换成二进制,在转成十六进制,4个代表一位(可以做最低四位与运算)
    e.负数的二进制表现形式:   原理:将二进制的0变成1,1变成0
    ============================================================================
    例子:-6,在内存中的实际是如下样子的 取反+1 反码是-1取反
        -6在内存中的表现形式: 0000-0000 0000-0000 0000-0000 0000-0110
        对他进行取反运算:    1111-1111 1111-1111 1111-1111 1111-1001
        然后在加1:          0000-0000 0000-0000 0000-0000 0000-0001
                ---------------------------------------------------
                      1111-1111 1111-1111 1111-1111 1111-1010 = -6
    =============================================================================
    f.整数的最高位是0,负数的最高位是1,1是由取反取来的。
 
4 变量
a.变量:就是将不确定的数据进行存储。也就是需要在内存中开辟一个空间。
    例:
*/
class VarDemo
{
    public static void main(String[] args)
    {
    //定义变量的格式:
    //数据类型 变量名 = 初始化值
    //Or
    //数据类型 变量名
    //变量名 = 初始化值
    }
}
/*
b.数据类型:
    byte (number, 1 byte)
    short (number, 2 bytes)
    int (number, 4 bytes)
    long (number, 8 bytes)
    float (float number, 4 bytes)
    double (float number, 8 bytes)ee
    char (a character, 2 bytes)
    boolean (true or false, 1 byte)
 
5 类型转换
    a.自动类型转换:
*/
class TypeDemo1
{
    public static void main(String[] args)
    {
        byte b = 3;
        b = b + 2;
        System.out.println(b);
        /*
        会报错,这是因为JAVA是强类型语言导致的
        两个不同类型的数值进行运算会进行自动类型提升,默认是小的类型往大
        的转换             
        */
    }
}
 
//b.强制类型转换:
class TypeDemo2
{
    public static void main(String[] args)
    {
        byte b = 3;
        b = (byte)(b + 2);  //这里将b+2的和强制转换成byte类型再赋值给B
        System.out.println(b);   
    }
}
//c.引出的疑问
class TypeDemo3
{
    public static void main(String[] args)
    {
        System.out.println('a' + 1); //打印98,是因为ascii码的原因
        System.out.println((char)('a' + 1)) //这里强制转换,打印b  
    }
}
 
//6 运算符
//6.1 算术运算符
class OperateDemo1  //算术运算符+-*/
{
    public static void main(String[] args)
    {
        int x = 4270;
        x = x / 1000 * 1000;
        System.out.println(x);   //2个int数据进行运算还是int行,结果为4000
    }
}
 
class OperateDemo2   //取模运算%
{
    public static void main(String[] args)
    {
        System.out.println(10%4); //取模,实际就是取余数,左边小于右边,结果是左边,左边等于右边结果是0,右边是1结果是0
        System.out.println(1%-4); //结果等于1
        System.out.println(-1%4); //结果等于-1,由以上得出,对一个负数取模,只看左边
    }
}
 
class OperateDemo3  //自曾自减++
{
    public static void main(String[] args)
    {
        int a = 3,b;  //定义了2个变量,a初始化值为3,b没有值,不能直接被使用
        b = a++;  //对a进行+1操作,并把+1后的值重新赋值给a
        System.out.println(b);  //3
        System.out.println(a);  //4
        System.out.println("a=" + a + ",b=" + b); //利用字符串连接符打印
        /*
        由上引出的疑问,为什么b是3?
        原因是b = a++ 是先把a的值赋值给b然后a再进行++运算
        而b = ++a 是先把a的值进行++运算,再赋值给b
        */
    }
}
 
class OperateDemo4  //字符串连接符+
{
    public static void main(String[] args)
    {
        System.out.println("haha" + "haha"); //字符串和任何数据使用+都是相连接,最终都会变成字符串
        System.out.println("MyNameIs" + 5 + 5); //打印MyNameIs55,把固定的值放到""里面去,把不固定的用+相连接就可以了
    }
}       
    //6.2 转意字符
class OperateDemo5 //通过\来转变后面字母或者符号的含义
{
    public static void main(String[] args)
    {
        System.out.println("Hello \nWorld!");  //用2行来输出,现在我们想载Hello World中间进行换行那么就在\n
        System.out.println("MyNameis Crow!"); 
        System.out.println("\"Hello World!\"");  //用\来转意"
        /*
            \n: 换行
            \b: 退格,相当于backspace
            \r: 按下回车键,Linux用\r,Windows系统中回车符是由2个字符表示的\r\n
            \t: 制表符,相当于tab键
        */
    }
}
 
    //6.3 赋值和比较运算符 
        //a.赋值运算符
class OperateDemo6 // += -= *= /= %=
{
    public static void main(String[] args)
    {
        int x = 3; //把右边赋值给左边
        x+=4; //x = x + 4把右边和左边的和赋值给左边,其他同理
    }
}
 
        //b.比较运算符
class OperateDemo7 //> < >= <= == !=
{
    public static void main(String[] args)
    {
       if(4 == 3) //相等于,运算完的结果要么是true要么是false
        {
            System.out.println("true");                 
        }else
        {
            System.out.println("false");
        }
       if(4 != 3) //不等于,运算完的结果要么是true要么是false
        {
            System.out.println("true");                 
        }else
        {
            System.out.println("false");
        }
    }
}
         
    //6.4 逻辑运算符
class OperateDemo8 //逻辑运算符用来连接boolean类型的表达式
{
    public static void main(String[] args)
    {
                /*
                 & And(与)说白了就是并且的意思
                    无论左边是true还是false,右边都运算
                 | Or (或)
                    两边都参与运算
                 ^ Xor(异或)
                 ! Not(非) 取反,一元运算符
                 &&And(短路)
                    当左边为false时,右边不运算
                 ||Or (短路)
                    当左边为true时,右边不运算
 
                 
                int x = 4;
                x>3 & x<6 = true & true = true;
                true & true = true;
                true & false = false;
                false & true = false;
                false & false = false;
                & : 只要两边的boolean表达式结果,有一个为false,结果就为false,只有两边都为true,结果才为true
                 
                true | true = true;
                true | false = true;
                false | true = true;
                false | false = false;
                | : 只要两边的boolean表达式结果,有一个为true,结果为true,只有两边都为false,结果才为false
 
                true ^ true = false;
                true ^ false = true;
                false ^ true = true;
                false ^ false = false;              
                ^: 就是和|有点不一样,当true ^ true时候为false,两边相同结果为false,两边不同结果是true
                */
    }
}
 
    //6.5 位运算符
class OperateDemo9
{
    public static void main(String[] args)
    {
        3<<2 //3左移2位,打印12,最高位原来的值是什么,就补什么
        //0000-0000 0000-0000 0000-0000 0000-0011
        //0000-0000 0000-0000 0000-0000 0000-1100  左移以后为12,左移就是乘以2的n次方
                 
        6>>2 //6又移2位
        //0000-0000 0000-0000 0000-0000 0000-0110
        //0000-0000 0000-0000 0000-0000 0000-0001 //右移以后为1,右移就是除以2的n次方
                 
        //>>> 无符号右移,不管最高位原来值是什么,都拿0补齐
    }
}
 
class OperateDemo10
{
    public static void main(String[] args)
    {
    /*
        6 & 3 = 2 //只要一边为false,结果就为false
        110   0 代表false
           &011   1 代表true
        -----
        010  = 2 
 
        6 | 5 = 7 //只要一边为true,结果就为true
        110
           |101
        ----
        111 = 7
 
        6 ^ 5 = 3 //两边相同为false
        110
           ^101
        ----
        011 = 3
 
        ~ //反码,就是二进制-1再取反
        System.out.println(~6); //-7
    */
    }
}
 
class OperateDemo11 //简单的思考,有趣的问题
{
    public static void main(String[] args)
    {
    /*
        7 ^ 4 ^ 4= 7
        111
           ^100
        ---
        011
           ^100
        ---
        111  = 7 //7^4^4结果=7
        //一个数异或同一个数2次,结果还是那个数,这个特性可以用来做简单的加密
    */
    }
}
 
    //6.6 位运算符练习
        //a.对2乘以8进行运算
            //a)因为是2的倍数,最有效的方式是用<<运算。
        //b.对两个整数的值进行互换
class OperateDemo12
{
    public static void main(String[] args)
    {
        int n = 3, m = 8;
        //1通过第三方变量
        int temp;
        temp = n;
        n = m;
        m = temp;
        //2不用第三方变量,如果n和m的值非常大,容易超出int范围
        n = n + m; //n = 11
        m = n - m; //m = 3
        n = n -m   //n = 8
 
        n = n ^ m;
        m = n ^ m; //(n^m)^m
        n = n ^ m; //n^(n^m)
    }
}
 
/*
      6.7 三元运算符
        格式:
            (条件表达式)?表达式1:表达式2
            如果条件结果为true,那么执行表达式1
            如果条件结果为false,那么执行表达式2
            三元运算符:
                好处:可以简化代码
                弊端:因为是一个运算符,所以运算为必须要有一个结果
*/
class OperateDemo13
{
    public static void main(String[] args)
    {
        int x = 3,y;
        y = (x>1)?100:200; //如果x的值>1那么把100赋值给y,如果<=1那么把200赋值给y
        System.out.println(y);
    }
}
 
//7 流程控制语句
    //7.1 判断结构
        //if 有3种形式
//a)
class IfDemo1
{
    public static void main(String[] args)
    {
        int x = 3;
        if(x>1)
        {
            System.out.println("Yes");
        }
        System.out.println("Over"); //这里无论If是否满足都执行,因为此句不再if控制区间内
    }
}
 
//b)
class IfDemo2
{
    public static void main(String[] args)
    {
        int x = 3;
        if(x>1)
        {
            System.out.println("Yes");
        }else
        {
            System.out.println("No"); //这里受else控制
        }
                         
    }
}
         
//c)
class IfDemo3
{
    public static void main(String[] args)
    {
        int x = 3;
        if(x>1)
        {
            System.out.println("x > 1");
        }else if (x == 1){
            System.out.println("x == 1");
        }else{
            System.out.println("No");
        }
                         
    }
}           
/*
      7.2 选择结构
        缺点:if能够判断区间,case不能,因为要判断区间必须把值全写出来,很费劲
             switch不能判断boolean值的类型
     
        switch(表达式) //表达式的值只能是4种类型byte short int char
        {
            case 取值1: //case和default的顺序是随意的,但是执行是从case开始的
                执行语句;
            break;
            case 取值2:
                执行语句;
            break;
            ......
            default:
                 执行语句;
            break;  //语句可以从break跳出,也可以从}结束
        }
*/
 
//a)
class SwitchDemo1
{
    public static void main(String[] args)
    {
        int x = 2;
        switch(x)
        {
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            case 3:
                System.out.println("3");
                break;
            case 4:
                System.out.println("4");
                break;
            default:
                System.out.println("default");
                break;   //最后这个break可以省略
        }
                         
    }
}
 
//b)
class SwitchDemo2
{
    public static void main(String[] args)
    {
    //需求,根据用户指定月份,打印该月份所属的季节
    //3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12 1 2 冬季
        int x = 4;
        switch(x)
        {
            case 3:
            case 4:
            case 5:
                System.out.println(x + "月是春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println(x + "月是夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println(x + "月是秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println(x + "月是冬季");
                break;
            default:
                System.out.println("NoNo");
        }
                         
    }
}
/*            switch应用场景:如果判断的具体数值不多,而且符合byte short int char这四种类型,虽然两个语句都
              可以使用,建议使用switch语句,因为效率稍高。
              其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围更广
*/
/*
      7.3 循环结构
      循环语句的特点:当一个语句需要循环很多次的时候使用,while或者for语句
      只是考虑变量的作用域问题
        a.while语句
            定义初始化表达式
            while(条件表达式)
            {
                执行语句;           
            }
*/
//a)
class WhileDemo1
{
    public static void main(String[] args)
    {
        int x = 1;
        while(x < 3) //条件满足,执行控制区间中的语句
        {
            System.out.println("Hello World!"); //打印2次
            x++;
        }
                         
    }
}
         
/*
          b.do while语句
            定义初始化表达式
            do
            {
                执行语句;
            }
            while(条件表达式); //do while最后判断条件,也就意味着do while无论如何都会执行至少一次
*/
//a)
class WhileDemo2
{
    public static void main(String[] args)
    {
        int x =1;
        do
        {
            System.out.println("Hello World!"); //打印2次
            x++;                            
        }
        while(x < 3);
                         
    }
}
//b)while无限循环最简单的表现形式
class WhileDemo3
{
    public static void main(String[] args)
    {
        while(true){}
    }
}
/*c.for语句
            for(初始化表达式;循环条件表达式;循环后的操作表达式)
            {
                执行语句;
            }
*/
//a)
class ForDemo1
{
    public static void main(String[] args)
    {
        for(int x = 0; x<3; x++)
        {
            System.out.println("Hello World!");
        }
    }
}
/*
              for和while的区别:
              for的变量作用域范围只能载for语句中有效,那么对于变量来讲,如果这个变量只作用与循环的增量
              来存在的话,那么建议使用for
*/
//b)
class ForDemo2
{
    public static void main(String[] args)
    {
        int x = 1;
        for(System.out.println("a"); x<3; System.out.println("c"))  //疑问,有结果吗?结果是什么?
        {
            System.out.println("d");
            x++;
        }
    }
}
                //由上可只for必须要有真假,不要一位写for循环就一定要写int x = 1;只要是合法的表达式就可以
//c)
class ForDemo3
{
    public static void main(String[] args)
    {
        int x = 1;
        for(System.out.println("a"); x<3; System.out.println("c"),x++)  //多个表达式出现的时候用,分开就可以了
        {
            System.out.println("d");
        }
    }
}
 
//d)for无限循环最简单的表现形式
class ForDemo4
{
    public static void main(String[] args)
    {
        for(;;){}  //对于for来讲,如果不写循环条件表达式,默认为true
    }
}
 
//e)获取1~10的和,并打印
    //e.a)利用while循环来实现
class ForDemo4
{
    public static void main(String[] args)
    {
        int sum = 0;
        int x = 1;
        while(x <= 10)
        {
            sum = sum + x;
            x++;
        }
        System.out.println("sum= " + sum);
    }
}
 
                //e.a)利用for循环来实现
class ForDemo5
{
    public static void main(String[] args)
    {
        int sum = 0;
        for(int x = 1; x <= 10; x++)
        {
            sum += x;
        }
        System.out.println("sum= " + sum);
    }
}
             
            //e)for语句嵌套
class ForDemo6
{
    public static void main(String[] args)
    {
        for(int x = 0; x < 3; x++)
        {
            for(int y = 0; y < 4; y++) //此循环体结束后才会执行父循环体
            {
                System.out.println("ok");
            }
        }
    }
}
 
    //7.4 其他流程控制语句
        //a.break(跳出)
class BreakDemo1
{
    public static void main(String[] args)
    {
        for(int x = 0; x<3; x++)
        {
            System.out.println("x= " + x);
            break; //跳出,这时候循环语句就结束了,break只能跳出当前循环
        }
    }
}
 
class BreakDemo2
{
    public static void main(String[] args)
    {
        w:for(int x = 0; x<3; x++)  //这里可以给for循环加标记
        {
            for(int y = 0; y<4; y++)
            {
                System.out.println("x= " + x);
                break w; //这里跳转到指定标记
            }
        }
    }
}
 
        //b.continue(继续)
class ContinueDemo1
{
    public static void main(String[] args)
    {
        for(int x = 0; x<3; x++)
        {
            if(x%2==1)
            {
                continue;  //continue结束本次循环,继续下一次循环,continue也可以加标记        
            }
            System.out.println("x= " + x);
        }
    }
}
/*
8 函数
    8.1 什么是函数?
        函数就是定义在类中的具有特定功能的一段独立小程序。
        函数也称为方法
    8.2 函数的格式:
        修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2, ...)
        {
            执行语句;
            return 返回值;
        }
        返回值类型: 函数运行后的结果的数据类型
        参数类型: 是形式参数的数据类型
        形式参数: 是一个变量,用于存储调用函数时传递给函数的实际参数
        实际参数: 传递给形式参数的具体数值
        return: 用于结束函数
        返回值: 该值会返回给调用者
    8.3 example:
*/
        //a.需要定义一个功能,打印x*3+5
class FunctionDemo1
{
    public static void main(String[] args)
    {
        int x = getResult(4); //这里调用函数
    }
 
    public static int getResult(int x) //函数定义在类中,被调用才执行
    {
        return x * 3 + 5;
    }
}
/*  
    8.4 函数的特点
        定义函数可以将功能代码进行封装,便于对该功能进行复用
        函数只有被调用才会执行
        函数的出现提高了代码的复用性
        对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的
        return语句如果在最后一行可以省略不写
        注意:
            函数中只能调用函数,不可以在函数内部定义函数
            定义函数时,函数结果应该返回给调用者,交由调用者处理
    8.5 没有具体返回值的情况
        a.//void练习,当函数没有返回值的时候,return可以不写
*/
class FunctionDemo2
{
    public static void main(String[] args)
    {
        getResult(4); //这里调用函数
    }
 
    public static void getResult(int x) //当函数运算后没有具体的返回值时,这是返回值类型用void来标识
    {
        System.out.println(x * 3 + 5;);
    }
}
/*
    8.6 函数的重载
        在同一个类中,允许存在一个以上同名函数,只要它们的参数个数或者参数类型不同即可重载
        重载示例:
            //返回两个整数的和
            int add(int x, int y){return x+y;}
            //返回三个整数的和
            int add(int x,int y,int z)return x+y+z;}
            //返回两个小数的和
            double add(double x,double y){return x+y;}
 
9 数组
    9.1 数组的定义:同一种类型的数据的集合,其实数组就是一个容器
    9.2 数组的好处:可以自动的给数组中的元素从0开始编号,方便操作这些元素
    9.3 数组的格式:
        a.格式1:
            元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
            示例: int[] arr = new arr[5];
        b.格式2:
            元素类型[] 数组名 = new 元素类型[]{元素1,元素2,......};
            示例: int[] arr = new arr[]{3,5,1,7};
                  int[] arr = {3,5,1,7};
    9.4 example:
*/
        //a.
class ArrayDemo1
{
    public static void main(String[] args)
    {
    //需求,想定义一个可以存储3个整数的容器
        int[] x = new int[2];
        x[0] = 4;
        x[1] = 6;
        System.out.println(x[0]);
        System.out.println(x[1]);
    }
}
    //9.5 数组操作常见的问题
        //b.
class ArrayDemo2
{
     public static void main(String[] args)
     {
        //Java中常见的错误
        int[] arr = new int[3];
        System.out.println(arr[3]); //这里编译不会报错,在运行的时候会报错
     }
}
 
        //c.    
class ArrayDemo3
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        arr = null; //这里把引用置空
        System.out.println(arr[1]); //编译时不会报错,当程序执行到这里是报错              
    }
}
    //9.6 数组的常见操作
        /*
        a.数组的遍历
        获取数组的元素,通常利用for循环来解决
         
        */
class ArrayDemo4
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{22,412,23,441}; //这里一个一个数比较麻烦,载数组中有一个属性可以直接获取到数组元素的个数。length
        //使用方法:数组名称.length =
        for(int x=0; x<arr.length; x++)
        {
            System.out.println("arr["+x+"]="+arr[x]";");
        }
    }
}
             
        //定义功能:打印数组中的元素,元素之间用逗号隔开.
class ArrayDemo5
{
    public static void main(String[] args)
    {
        int[] arr = new int[4];
        arr[0] = 32;
        arr[1] = 47;
        arr[2] = 76;
        arr[3] = 51;
        printArray(arr);
    }
                 
    public static void printArray(int[] arr)
    {
        for(int x=0; x<arr.length; x++)
        {
            if(x!=arr.length-1)
            {
                System.out.print(arr[x] + ",");
            }else
            {
                System.out.println(arr[x]);
            }
        }
    }
}           
        //给定一个数组{2,1,5,8,3,0,7},获取数组中的最大值,最小值
class ArrayDemo6
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{2,1,5,8,3,0,7};
        /*
        1.获取最值需要进行比较,每次比较都会有一个较大的值,因为该值不确定,那么通过变量进行临时存储
        2.让数组中每一个元素都和这个变量中的值进行比较,如果大于变量中的值,就用该变量记录较大的值。
        3.当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值。
        */
        int max = getMax(arr);
        System.out.println("max = " + max);
    }
                 
    public static int getMax(int[] arr)
    {
        int max = arr[0];
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>max)
            {
                max = arr[x];
            }
        }
        return max;
    }
 
}
 
        //思考:可不可以将临时变量初始化为0呢?
class ArrayDemo7
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{2,1,5,8,3,0,7};
        int max = getMax(arr);
        System.out.println("max = " + max);
    }
                 
    public static int getMax(int[] arr)
    {
        //int max = arr[0];
        int max = 0 //这里把它初始化为0,是可以的,因为是把它看成初始化为数组中任意一个下标
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[max])
            {
                max = x;
            }
        }
        return arr[max]; //这里返回数组是max下标的元素
    }
 
}
             
        //获取最小值,作为练习
         
/*
        数组的排序
            a.选择排序
*/ 
class ArrayDemo8
{
    public static void SelectSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=x+1; y<arr.length; y++)
            {
                if(arr[x]>arr[y])
                {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
 
    public static void printArray(int[] arr)
    {
        for(int x=0; x<arr.length; x++)
        {
            if(x!=arr.length-1)
            {
                System.out.println("Arr[]={" + arr[x] +"},");
            }else
            {
                System.out.println("Arr[]={" + arr[x] +"}");
            }
        }
    }
 
    public static void main(String[] args)
    {
        int[] arr = new int[]{1,5,3,6,8,7,0,9,2};
        System.out.println("=============排序前=================");
        printArray(arr);
        System.out.println("=============排序后=================");
        SelectSort(arr);
        printArray(arr);
    }
}
 
/*
        数组的排序
            b.冒泡排序
*/
class ArrayDemo9
{
    public static void BubbleSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=0; y<arr.length-x-1; y++)
            {
                if(arr[y]>arr[y+1])
                {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
 
    }
 
    public static void printArray(int[] arr)
    {
        for(int x=0; x<arr.length; x++)
        {
            if(x!=arr.length-1)
            {
                System.out.println("Arr[]={" + arr[x] +"},");
            }else
            {
                System.out.println("Arr[]={" + arr[x] +"}");
            }
        }
    }
 
    public static void main(String[] args)
    {
        int[] arr = new int[]{1,5,3,6,8,7,0,9,2};
        System.out.println("=============排序前=================");
        printArray(arr);
        System.out.println("=============排序后=================");
        BubbleSort(arr);
        printArray(arr);
    }
}
/*
        数组的排序
            c.封转位置置换功能
*/
class ArrayDemo10
{
    public static void main(String[] args)
    {
 
    }
     
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}
        //数组的查找
class ArrayDemo11
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{1,5,3,6,8,7,0,9,2};
        int index = getIndex(arr,3);
        System.out.println("index=" + index);
    }
    //定义功能:获取key第一次出现在数组中的位置,如果返回值是-1,那么代表该key在数组中不存在.
    public static int getIndex(int[] arr,int key)
    {
        for(int x=0; x<arr.length; x++)
        {
            if(arr[x]==key)
                return x;
        }
        return -1;
    }
}
            //a.折半查找
class ArrayDemo12
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{1,3,5,6,7,8,9};
        int index = halfSearch(arr,7);
        System.out.println("index=" + index);
    }
    //折半查找,可以提高效率,但是必须要保证该数组是有序的数组.
    public static int halfSearch(int[] arr,int key)
    {
        int max,mid,min;
        min = 0;
        max = arr.length-1;
        mid = (max+min)/2;
         
        while(arr[mid]!=key)
        {
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            if(min>max)
                return -1;
            mid = (max+min)/2;
        }
        return mid;
    }
}
            //b.折半查找的第二种方式
class ArrayDemo13
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{1,3,5,6,7,8,9};
        int index = halfSearch_2(arr,7);
        System.out.println("index=" + index);
    }
    //折半查找,可以提高效率,但是必须要保证该数组是有序的数组.
    public static int halfSearch_2(int[] arr,int key)
    {
        int min = 0,max = arr.length-1,mid;
        while(min<=max)
        {
            mid = (max+min)>>1;
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            else
                return mid;
             
        }
        return -1;
    }
}
 
        //利用程序进行进制转换
        //a.第一种方法
class ToBin1
{
    public static void main(String[] args)
    {
        toBin(6);
    }
    //十进制转二进制
    public static void toBin(int num)
    {
        while(num>0)
        {
            System.out.println(num%2);
            num = num / 2;
        }
    }
}
        //b.第二种方法
class ToBin2
{
    public static void main(String[] args)
    {
        toBin(6);
    }
    //十进制转二进制
    public static void toBin(int num)
    {
        StringBuffer sb = new StringBuffer();  //利用StringBuffer方法进行存储
         
        while(num>0)
        {
            sb.append(num%2);
            num = num / 2;
        }
        System.out.println(sb.reverse());
    }
}
    //十进制转十六进制
class ToBin3
{
    public static void main(String[] args)
    {
        toHex(60);
    }
    public static void toHex(int num)
    {
        for(int x=0; x<8; x++)
        {
            int temp = num & 15;
            if(temp>9)
                System.out.println((char)(temp-10+'A'));
            else
                System.out.println(temp);
             
            num = num >>> 4;           
        }
    }
}
    /*
      查表法
0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
将所有元素临时存储起来,建立对应关系。每一次&15后的值作为索引
去查建立好的表。就可以找到对应的元素,这样就比-10+'a'简单的多
通过数组的形式建立表
*/
class ToBin4
{
    public static void main(String[] args)
    {
        toHex(60);  
    }
     
    public static void toHex(int num)
    {
        char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};  
        for(int x=0; x<8; x++)
        {
            int temp = num & 15;
            System.out.println(chs[temp]);
            num = num >>> 4;
        }
    }
}
//对结果还是不满意,我们需要只显示有效位,并且反转结果
class ToBin5
{
    public static void main(String[] args)
    {
        toHex(60);  
    }
     
    public static void toHex(int num)
    {
        char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};  
        //定义一个临时数组,用于反转结果
        char[] arr = new char[8];
        int pos = arr.length;
         
        while(num!=0)
        {
            int temp = num & 15;
            arr[--pos] = chs[temp];
            num = num >>> 4;
        }
         
        //存储数据的arr数组遍历
        for(int x=pos; x<arr.length; x++ ) //这里数组指针倒着存
        {
            System.out.print(arr[x] + ",");
        }
    }
}


标签: Java基础
共有 人打赏支持
粉丝 6
博文 13
码字总数 49122
×
黑武士
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: