JavaSE基础

作者: MengkZhang | 来源:发表于2017-12-15 14:34 被阅读0次

大数据新鲜干货，一起学习吧
JavaSE 基础学习之五 —— IO 操作 (java. io
JAVA(1) 基础与环境配置
简述JavaEE学习流程
JavaSE基础
JAVASE基础
JavaSE基础
JavaSE基础
Javase基础
JavaSE基础

1，Java虚拟机以及jdk和jre的介绍

为什么JAVA可以跨平台？

和C++ 相比，很重要的一点就是：C++ 编译生成的是纯二进制的机器指令，而JAVA编译生成的是非纯二进制的字节码。而这种基于Unicode的字节码是不依赖于特定的计算机硬件架构而存在的——这就意味着只要有JVM环境，你的字节码就可以在任何平台上运行。其次，JAVA字节码的二进制数据以固定的格式进行存储和传输，消除了字节顺序的干扰。

JRE：Java Runtime Environment

是Java程序的运行环境。既然是运行，当然要包含JVM，也就是所谓的Java虚拟机，还有所以的Java类库的class文件，都在lib目录下，并且都打包成了jar。

JDK：Java Development Kit

是Java的开发工具包，主要包含了各种类库和工具，当然也包含了另外一个JRE，那么为什么要包含另外一个JRE呢？而且<JDK安装目录>/JRE/bin目录下，包含有server一个文件夹~包含一个jvm.dll，这说明JDK提供了一个虚拟机。另外，JDK的bin目录下有各种Java程序需要用到的命令，与JRE的bin目录最明显的区别就是JDK文件下才有javac，这一点很好理解，因为JRE只是一个运行环境而已，与开发无关。正因为如此，具备开发功能的JDK所包含的JRE下才会同时有server的JVM，而仅仅作为运行环境的JRE下，只需要server的jvm.dll就够了。
注意：JDK所提供的运行环境和工具度需要进行环境变量的配置以后，才能使用，最主要的配置就是把<JDK安装目录>/bin目录设置为Path环境变量值的一部分。
另外，安装JRE的时候安装程序会自动把JRE的java.exe添加到了系统变量中。系统变量Path的最前面有%SystemRoot%system32;%SystemRoot%;这样的配置，那样到Windows/system32目录下main去看看，会发现一个java.exe文件。这样就无需配置环境变量，也可以运行Java程序了。
可以这样回答：
JDK是Java的开发工具，它不仅提供了Java程序运行所需的JRE，还提供了一系列的编译，运行等工具，如javac，java，javaw等。JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）及核心类库。

2，Java环境变量（主要是用来找到编译运行Java程序的命令javac和java命令）

JAVA_HOME环境变量的配置

解决的办法:新增一个环境变量JAVA_HOME来保存那个可能发生改变的路径,然后在PATH中通过%来进行引用我们初设的JAVA_HOME来配置那个路径

JAVA_HOME=G:\JDK\jdk1.7.0_51\

PATH=%JAVA_HOME%\bin

3，Java标识符

标识符:编写Java程序所使用到的所有单词

标识符的分类
自定义标识符

 关键字（保留字）

标识符的构成:字母/数字/下划线/$ 注意:数字是不能开头的

下面那些是合法的标识符
ahdajdfh___ 123 $_ _$ 123asd 123 $_123_abc 123
关键字:JAVA程序中使用了的那些单词
class puclic int float void if else while do for this super return ....

自定义标识符注意:自定义的标识符不能够是关键字

4，变量和常量

变量:在程序的运行过程中可以发生改变的量就称为变量

  变量属于标识符------>他的命名必须要遵从标识符的命名规范   
    标量的命名构成:字母  数字  下划线  $构成
    变量的命名有三种命名方法
        帕斯卡命名法
           特点是什么:每个单词的首写字母必须要大写------->类的命名   UserName   UserAddress   
        驼峰命名法
           特点是什么:第一个单词的首写字母小写，其余的每个单词的首写字母大写 userName----->变量的命名   
        匈牙利命名法
           特点是什么:每个单词之间使用下划线进行连接-------->对应的是Android中所有布局文件的命名------>user_name

****在JAVA中一般情况下咋们遵从驼峰命名法******
变量的命名一般情况下要遵从见名知意
userName password userTel

语法：编写程序所遵循的规则(*******)

变量的声明
语法规则
数据类型变量名;
变量:int score; //表示的是申明了一段存储空间(4个字节) 在这段存储空间上只能存储 int这个类型的数据
short b;

变量一旦申明那么在内存上就会开辟一段存储空间这段空间的具体的大小是由变量的数据类型来决定的
变量一定是要先申明后使用

变量的使用
直接使用变量名就可以来操作这个变量所指向的数

变量的初始化:----->解析:给变量赋值
两种方式:
1:在申明变量的时候直接赋值
int a=123;
2:申明变量之后，使用变量之前来进行赋值
int a;
....
a=2;
变量的分类:
全局变量:申明在类里面非语句块中的变量
语句块:在类中由{}括起来的部分就叫做语句块函数整体也可以看成是一个语句块
全局变量的生命周期和作用域:
生命周期：变量能够起作用的一个范围------>啥时候用这个变量有意义
全局变量的生命周期是整个类---->也就是说在这个类里面任何的地方都是可以使用的
局部变量
定义在语句块中的变量就是局部的变量
局部变量的生命周期就是整个语句块
当局部变量和全局变量重名的时候，在局部变量的语句块中以局部变量优先为原则,除了语句块中以外那么就使用的是全局变量

;表示的意义:语句结束的标志

**常量:在程序的运行过程中不能够发生改变的量圆周率 **

常量的命名规范:常量名的所有的单词均需要大写而且各个单词之间需要使用下划线来进行连接 COLOR_TYPE SELECT_TYPE
常量在JAVA中的一般的定义格式是: public static final (int/String/Long/byte) SELECT_TYPE=1;
常量是必须有值的，如果没有报错

5，Java数据类型

基本类型和引用类型

Java八种基本类型

$\color{red}{四种整数类型（byte、short、int、long）}$
$\color{red}{两种浮点数类型（float、double）}$
$\color{red}{一种字符类型（char）}$
$\color{red}{一种布尔类型(boolean)}$

记忆：

8位：Byte（字节型）
16位：short（短整型）、char（字符型）
32位：int（整型）、float（单精度型/浮点型）
64位：long（长整型）、double（双精度型）
最后一个：boolean(布尔类型

6,运算符

算数运算符

+   -   *   /  %(求余)   ++(自增)   --(自减);   +=   -=   *=   /=

a++ ------->a=a+1 ++a ---------->a=a+1
a-- --a ------>a=a-1

$\color{red}{ a++:表示的是先参加逻辑运算再自增 ++a:先自增再参加逻辑运算}$

逻辑运算:

在自增或者自减的表达式中除去本身的自增或者自减还存在其余的运算均称为逻辑运算

eg:
int a=3,b=5;
int a,b,c=23,d;

int a;
int b;
a+=b==>  a=a+b;   a=8
a-=b==>a=a-b;     a=-2
a*=b==>a=a*b;     a=15
a/=b==>a=a/b;     a=0

逻辑运算符

> < >= <= != == & || ! &&

 逻辑运算的结果只有两种   true/false
 3>2

&和&&的区别：

&和&&都是逻辑运算符，都是判断两边同时真则为真，否则为假；但是&&左边为false之后，右边的语句就不执行了，而&则还是继续执行，直到整个条件语句执行完为止

三目运算符

逻辑判断?表达式一:表达式二      表达的意思是:如果前面的表达式成立的话(true) 那么执行表达式一   否则执行表达式二

求两个数中的最大的数

三木运算符的嵌套:    嵌套:三木运算符里面还有三目运算符

移位运算符 >> <<

20 00 00000000 00000000 00000000 000101

问题:2<<20 ?值是怎么来的

image.png

7,循环语句

for循环

class ForDemo 
{
    public static void main(String[] args) 
    {
        /*
        
        for(初始化表达式；循环条件表达式；循环后的操作表达式)
        {
            执行语句；(循环体)
        }

        

        for(int x = 1; x<3; x++)
        {

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

        }
        */
        int x = 1;
        for(System.out.println("a");x<3; System.out.println("c"))
        {
            System.out.println("d");
            x++;
        }

//      for(int a=0,b=0; a<3; a++,b--)

        //a d c d c
    }
}

for循环test

class ForTest 
{
    public static void main(String[] args) 
    {
        /*
        用for完成累加。
        */
        int sum = 0;
        for(int x=1; x<=10; x++)
        {
            sum = sum + x;  
        }

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

        /*
        for和while的特点：
        1,for和while可以互换。
        2,格式上的不同，在使用上有点小区别。
            如果需要通过变量来对循环进行控制，该变量只作为循环增量存在时，区别就体现出来了。
        */

        //打印1~10十个数字
        int x = 1;
        while(x<5)
        {
            System.out.println("x="+x);
            x++;
        }
        System.out.println("x===="+x);

        for(int y=1; y<5; y++)
        {
            System.out.println("y="+y);
        }
        System.out.println("y====="+y);


        //无限循环最简单的形式。
//      while(true){}

//      for(;;){}

        什么时候使用循环结构呢？
        当对某些代码执行很多次时，使用循环结构完成。
        
        当对一个条件进行一次判断时，可以使用if语句。
        当对一个条件进行多次判断时，可以使用while语句。 

        注意：
            在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。
            循环通常情况下，需要定义条件，需要控制次数。

        

    }
}

关于for循环的各种打印Demo

class  ForForDemo
{
    public static void main(String[] args) 
    {
        //大圈套小圈思想。
        /*
        for(int x=0; x<3; x++)
        {
            for(int y=0; y<4; y++)
            {
                System.out.println("ok");
            }
        }
        */

        /*
        
        *****
        *****
        *****
        *****
        
        */
        for(int x=0; x<4; x++)//外循环控制的是行数
        {
            for(int y=0; y<5; y++)//内循环控制的是每一行的个数 
            {
                System.out.print("*");
            }
            System.out.println();
        }
    
        
        
    }
}


class ForForTest 
{
    public static void main(String[] args) 
    {

        /*
        
        *****
        ****
        ***
        **
        *


        */

        /*
        int z = 5;
        for (int x = 1; x<=5 ;x++ )//1-5 1-4 1-3//1-5 2-5 3-5
        {
            for (int y=1; y<=z ; y++ )
            {
                System.out.print("*");
            }
            System.out.println();
            z--;
        }
        */
        /*

        int z = 1;
        for (int x = 1; x<=5 ;x++ )//1-5 1-4 1-3//1-5 2-5 3-5
        {
            for (int y=z; y<=5 ; y++ )
            {
                System.out.print("$");
            }
            System.out.println();
            z++;
        }
        */
        for(int x=1; x<=5; x++)
        {
            for(int y=x; y<=5; y++)
            {
                System.out.print("*");
            }
            System.out.println();
        }






        /*

        *
        **
        ***
        ****
        *****
        */
        System.out.println("----------");
        for (int x=1; x<=5 ;x++ )
        {
            for (int y=1;y<=x ;y++ )
            {
                System.out.print("*");
            }
            System.out.println();
        }



        System.out.println("----------");
        /*

        54321
        5432
        543
        54
        5


        */
        for (int x=1; x<=5; x++ )
        {
            for (int y=5; y>=x ;y-- )
            {
                System.out.print(y);
            }
            System.out.println();
        }


        System.out.println("----------");
        /*
        1
        22
        333
        4444
        55555
        
        */

        for (int x=1; x<=5 ; x++)
        {
            for (int y=1;y<=x ;y++ )
            {
                System.out.print(x);
            }
            System.out.println();
        }
    }
}


class ForForTest2 
{
    public static void main(String[] args) 
    {

        /*
        
        * * * * * 
        -* * * *
        --* * * 
        ---* * 
        ----*

        */
        for(int x=1; x<=5; x++)
        {
            for(int y=1; y<x; y++)
            {
                System.out.print(" ");
            }
            
            for(int z=x; z<=5; z++)
            {
                System.out.print("* ");
            }

            System.out.println();
        }


        /*
        
          *
             * *
            * * *
           * * * * 
          * * * * *

        */
    }
}

打印九九乘法表

class ForFor99 
{
    public static void main(String[] args) 
    {

        /*
        九九乘法表
        1*1=1
        1*2=2 2*2=4
        1*3=3 2*3=6 3*3=9
        
        */

        for (int x=1; x<=9 ;x++ )
        {
            for (int y=1; y<=x ;y++ )
            {
                System.out.print(y+"*"+x+"="+y*x+"\t");
            }
            System.out.println();
        }


        /*
        \n:回车：
        \t:制表符。
        \b:退格。
        \r: 按下回车键。

        windows系统中回车符其实是由两个符号组成的 \r\n.
        linux中回车符是 \n.

            
        System.out.println("\\hello world\\");
        */
    
    }
}

while循环

class  WhileDemo
{
    public static void main(String[] args) 
    {

        /*
        while(条件表达式)
        {
            执行语句；
        }

        */
        int x = 1;
        while(x<3);
        {
            System.out.println("x="+x);

            x++;
        }

        
    }
}

while循环test

class WhileTest 
{
    public static void main(String[] args) 
    {

        /*
        
        练习：
        获取1到10 10个数字的和。

        0 + 1
        1 + 2
           3 + 3
             6 + 4
            10 + 5
        思路：
        1，每次参与加法的数值不确定。
        2，每次的出现的和数据也不确定。
        3，发现参与加法运算的数值有递增规律。
        4，每一次都是加法运算在重复，并且都是和再加上下一个数值。

        步骤：
        1，定义一个变量，记录住参与加法运算的数据。
        2，定义一个变量，记录中每一次的出现的和。
        3，对于记录参与加法运算的数据进行自增。
        4，因为加法运算需要重复，就要想到循环结构。
        */


        //累加思想。

        int x = 1;//记录参与加法的数据。
        int sum = 0;//记录住每一次的和。
        while(x<=100)
        {
            sum = sum + x;
            
            x++;
        }

        System.out.println("sum="+sum);
      
    }
}

1~100之间 6的倍数出现的次数。

class  WhileTest2
{
    public static void main(String[] args) 
    {

        /*
        练习：
        1~100之间 6的倍数出现的次数。
        要求：自己独立完成思想的书写。和步骤的文字描述。


        */

//      计数器思想
        int x = 1;
        int count = 0;
        while(x<=100)
        {
            if(x%6==0)
                count++;
//              System.out.println("x="+x);
            x++;
        }

        System.out.println("count="+count);
    }
}

8,函数（方法）

函数（方法）：系列的指令的一个集合
集合：指的是在某种情况下完成一种特定的功能 (打开wifi/检测网络状 /检测Sdcard卡状态/两个数求大小....)

public static void main(String args){}

public：主要是为了让JVM在任何情况下都能够访问我们的方法

static:是因为方便我们的JVM在调用的时候不需要new对象直接通过类名就可以访问了

void:因为方法的调用者是JVM所以说返回值返回给JVM是没有任何意义的

main:这个表示的是主方法

String 是因为我们在运行的时候是可以直接给参数的在运行的时候直接在后面给参数多个参数之间使用空格隔开

访问的修饰符返回值的类型(数据类型(基本的数据类型/引用的数据类型)) 方法名(方法名遵从变量的命名规范(驼峰命名法(首写字母小写)))(形参列表){方法体}

注意:方法如果没有返回值的话那么就使用void
方法名要做到见名知意

形参:形式参数

  形式参数的构成
  数据类型  变量名;--------->简单点说就是在方法体里面申明一个全局的变量   eg:int a

行参列表:多个形式参数通过逗号进行连接就形成了一个形参列表

       eg:int a,byte a,boolean c
       注意:形参列表中如果有多个类型相同的变量  是不能够被写成  int a,b,c(X)  必须是一个变量对应一个数据类型

return:表示的是返回一个数据
注意:程序一旦遇到return那么整个方法就结束了...也就是说即使后面还有语句也不会执行

函数如何调用: 函数名(实参列表)
实参:实实在在的参数也就是调用函数的时候传递过去的参数
注意:强类型语言中(JAVA)中，形参列表的个数和实参列表的个数是一一对应的----->表示的含义:将我们传递过去的实参赋值给(对应)的形参

方法的返回值都返回给了调用处

阶乘 5!=12345 .....4!=123*4

5!=4!5
4!=3!4
3!=2!*3

2!=1!*2

public class Test01 {  
    public static void main(String[] args) {  
        System.out.println(f(5));  
    }  
  
    public static int f(int n) {  
        if (1 == n)   
        return 1;  
        else   
        return n*(n-1);  
    }  
}

函数的递归:自己调用自己

使用Java代码求数列：1，1，2，3，5，8......第40位的数

public class Test_02_Fibonacci {  
    public static void main(String[] args) {  
        System.out.println(f(6));  
    }  
    
    //求数列：1，1，2，3，5，8......第40位的数 
    public static int f(int n ) {  
        if (1== n || 2 == n)   
            return 1;  
        else  
            return f(n-1) + f(n-2);  
    }  
}

8.1函数的重载

函数重载的定义：在同一个类中，有一个以上的同名函数，只要函数的参数列表或参数类型不一样即可，与返回值无关，这些统称为方法的重载。

/*
需求：函数的重载。 
*/

class FunctionDemo4 
{
    public static void main(String[] args) 
    {
//      add(4,6,9);
//      System.out.println("Hello World!");
        printCFB(7);
    }

    /*
    函数的重载。

    1，同一个类，
    2，同名。
    3，参数个数不同。or 参数类型不同。
    4，函数重载和返回值类型无关。
    5，java是严谨性语言，如果函数出现的调用的不确定性，会编译失败。


    */

    //加法运算。两个整数的和。
    public static int add(int a,int b)
    {
        return a+b;
    }
    

    //加法运算。两个小数的和。
    public static double add(double a,double b)
    {
        return a+b;
    }

    //加法运算，三个整数的和。 
    public static int add(int a,int b,int c)
    {
        return add(a,b)+c;
    }


    /*
    打印乘法表。
    */
    public static void printCFB(int num)
    {
        for(int x=1; x<=num; x++)
        {
            for(int y=1; y<=x; y++)
            {
                System.out.print(y+"*"+x+"="+y*x+"\t");
            }
            System.out.println();
        }
    }

    /*
    打印标准乘法表。
    */
    public static void printCFB()
    {
        printCFB(9);
    }

}

9，数组

数组:
定义:一组具有相同数据类型的变量的集合

数组中的元素也是变量

组:数据的个数不止一个

数组的定义:
动态的定义
数据类型数组名=new 数据类型[数组元素的个数];

数据类型数组名=new 数据类型[数组元素的个数];

数据类型:基本的数据类型也可以是引用的数据类型

=:赋值运算符

new：表示的是创建一个对象

数组元素的个数：表示的是这个容器中能够存放的元素的个数

int arr=new int[10];--->表示的意义是:开辟了一段能够存储10个int类型数据的空间

静态的定义

简单点说就是在申明数组的时候直接给赋值

数据类型数组名={值,值};

int arr={12,34,56};

数组的初始化

两种方式

第一种方式在定义数组的时候直接赋值（静态定义）

第二种方式在定义完数组之后使用数组之前来进行赋值

数组元素的访问

数组名[下标]

数组的遍历:数组的遍历：就是把数组元素从前到后的访问一遍

数组的遍历一般采用循环

需求:从控制台输入10个数把其中大于50的给打印出来

a.length:这个获取的是数组的长度

数组的访问绝招:for....each来进行访问

格式: for(数据类型:迭代的变量数组名){}

数据类型:数组中每个元素(可以是单个的数据也可以是数组)的数据类型

迭代的变量:指的是每一次迭代返回的数据(简单点说就是每一次从数组里面取回来的数赋值给了这个变量我们要访问这个数据的话那么只需要访问这个变量即可)

数组内存图解

image.png

内存的划分：

1，寄存器。

2，本地方法区。

3，方法区。

4，栈内存。

存储的都是局部变量。

而且变量所属的作用域一旦结束，该变量就自动释放。

5，堆内存。

存储是数组和对象(其实数组就是对象) 凡是new建立在堆中。

特点：

1，每一个实体都有首地址值。

2，堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数0.0或者0.0f，boolean false char '\u0000'

3，垃圾回收机制。

数组的Demo

class ArrayDemo3
{
    public static void main(String[] args) 
    {
        //格式1
        /*
        需要一个容器，但是不明确容器的具体数据。
        */
//      int[] arr = new int[3];


        /*
        需要一个容器，存储已知的具体数据。
        */
        //元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
//      int[] arr = new int[]{89,34,270,17};
        int[] arr = {89,34,270,17};

        /*
        对数组操作最基本的动作就是存和取。
        核心思想：就是对角标的操作。
        
        */

        System.out.println("length:"+arr.length);
        for(int x=0; x<arr.length ; x++)
        {
            System.out.println("arr["+x+"] = "+arr[x]+";");//arr[0] = 89;
        }

        for(int x=arr.length-1; x>=0; x--)
        {
            System.out.println("arr["+x+"] = "+arr[x]+";");//arr[0] = 89;
        }
//      System.out.println(arr[1]);
//      System.out.println(arr[2]);
//      System.out.println(arr[3]);
        





    }
}

遍历数组 && 冒泡排序 && 选择排序

image.png

import java.util.*;

class ArrayDemo4 
{

    //遍历数组的功能。
    public static void printArray(int[] arr)
    {
        System.out.print("[");
        for(int x=0; x<arr.length; x++)
        {
            if(x!=arr.length-1)
                System.out.print(arr[x]+", ");
            else
                System.out.println(arr[x]+"]");
        }
    }
    public static void main(String[] args) 
    {
        int[] arr = {34,19,11,109,3,56};

//      int max = getMax_2(arr);
//      System.out.println("max="+max);

        printArray(arr);

//      selectSort(arr);
//      bubbleSort(arr);
//      Arrays.sort(arr);
        selectSort_2(arr);

        printArray(arr);
    }

    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    /*
    冒泡排序。
    */
    public static void bubbleSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=0; y<arr.length-1-x; y++)
            {
                if(arr[y]>arr[y+1]) 
                {
                    swap(arr,y,y+1);
                    /*
                    int temp  = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                    */
                }
            }   
        }
    }


    /*
    选择排序。
    */
    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])
                {
                    swap(arr,x,y);
                    /*
                    int temp  = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                    */
                }
            }
        }
    }

    public static void selectSort_2(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            int num = arr[x];
            int index = x;
            for(int y=x+1; y<arr.length; y++)
            {
                if(num>arr[y])
                {
                    num = arr[y];
                    index = y;
                }
            }
            if(index!=x)
                swap(arr,x,index);
        }
    }


    /*
    获取数组中的最大值。
    思路：
    1，需要进行比较。并定义变量记录住每次比较后较大的值。
    2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
        如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。 
    3，遍历结果，该变量记录就是最大值。

    定义一个功能来是实现。
    明确一，结果。
            是数组中的元素。int .
    明确二，未知内容。
            数组.
    */
    public static int getMax(int[] arr)
    {
        //定义变量记录较大的值。
        int maxElement = arr[0];//初始化为数组中的任意一个元素。
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>maxElement)
                maxElement = arr[x];
        }
        return maxElement;
    }
    public static int getMax_2(int[] arr)
    {
        //定义变量记录较大的值。
        int maxIndex = 0;//初始化为数组中任意一个角标。
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[maxIndex])
                maxIndex = x;
        }
        return arr[maxIndex];
    }
}

二分查找

image.png

import java.util.*;
/*
面试题：
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
那么个元素的存储的角标为如何获取。
{13,15,19,28,33,45,78,106};
*/
class ArrayDemo5 
{
    public static void main(String[] args) 
    {
//
//      int[] arr = {4,1,8,7,3,8,2};
        int[] arr = {13,15,19,28,33,45,78,106};
        int index = halfSearch_2(arr,5);
        System.out.println("index="+index);

        int index1 = Arrays.binarySearch(arr,5);//如果存在返回的具体的角标位置，不存在返回的是  -插入点-1
        System.out.println("index1="+index1);
    }
    /*
    二分查找法。
    
    */
    public static int halfSearch(int[] arr,int key)
    {
        int max,min,mid;
        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(max<min)
                return -1;

            mid = (max+min)/2;
        }
        return mid;

    }

    public static int halfSearch_2(int[] arr,int key)
    {
        int max,min,mid;
        min = 0;
        max = arr.length-1;

        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 -min-1;
    }


    /*
    数组常见功能：查找。
    */
    public static int getIndex(int[] arr,int key)
    {
        for(int x=0; x<arr.length; x++)
        {
            if(arr[x]==key)
                return x;
        }
        return -1;
    }
}

二维数组

二维数组图解

image.png

/*
二维数组定义的格式。
*/


class  Array2Demo
{
    public static void main(String[] args) 
    {

//      int[] arr = new int[3];  
//      System.out.println(arr);//[I@1fb8ee3  @左边是实体的类型。 @右边是实体的哈希值。

//      int[][] arr = new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素。
//      System.out.println(arr);//直接打印二维数组。   [[I@c17164
//      System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。 [I@1fb8ee3
//      System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 0



//      int[][] arr = new int[3][];
//      System.out.println(arr);//直接打印二维数组。   [[I@c17164
//      System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。null
//      System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 NullPointerException


    
//      int[][] arr = new int[3][2];
//      System.out.println(arr.length);//打印二维数组的长度。其实就是一维数组的个数。
//      System.out.println(arr[1].length);//打印二维数组中角标为1一维数组的长度。

        int sum = 0;
        int[][] arr = {{3,1,7},{5,8,2,9},{4,1}};

        for(int x=0; x<arr.length; x++)
        {
            for(int y=0; y<arr[x].length; y++)
            {
//              System.out.print(arr[x][y]+",");
                sum += arr[x][y];
                
            }
        }
        System.out.println("sum="+sum);


//      甲：30 59 28 17
//      乙；37 60 22 19
//      int[] arr = {{30,59,28,17},{37,60,22,19}};

        int[][][] arr = new int[3][2][4];
    }
}

/*
int[] x,y[];
int[] x;
int[] y[];


a
x = y;

b
x = y[0];

c
x[0] = y[0];

d
x[0] = y[0][0];

e
x[0] = y;
*/

大数据新鲜干货，一起学习吧
大数据语言基础语言基础(视频) JavaSE 语言基础 Eclipse 开发环境、 JavaSE 7.0 AP...
JavaSE 基础学习之五 —— IO 操作 (java. io
接上篇《JavaSE 基础学习之四 —— 异常的处理》五. JavaSE 基础学习 —— IO 操作 (java...
JAVA(1) 基础与环境配置
基础了解、环境配置基础 java ~~~ 1995年诞生 javaSE~~~ java基础版 javaEE...
简述JavaEE学习流程
1，Java基础 Java基础也就是JavaSE，Java SE（Java Platform, Standard ...
JavaSE基础
面向对象都有哪些特性以及你对这些特性的理解一.继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被...
JAVASE基础
第一阶段java基础复习 1.软件开发基础 1.1开发软件的目的提高人个计算机之间的交互方式 1.2软件软件=...
JavaSE基础
1.干什么之前要先有思路，在有总体的思路构想后，不断在思路的指导下面做事情和完善相应的细节。 2.理解越多，需要记...
JavaSE基础
1，Java虚拟机以及jdk和jre的介绍为什么JAVA可以跨平台？和C++ 相比，很重要的一点就是：C++ ...
Javase基础
Javase 2016年9月23日 8:29 一、现在流行的计算机语言 C:面向过程 C++：面向过程+面向对象 ...
JavaSE基础
面向过程与面向对象的区别: 面向过程性能比面向对象性能高,但是不容易维护,不容易调用,也不容易扩展面向对象性能比...

JavaSE基础

1，Java虚拟机以及jdk和jre的介绍

2，Java环境变量（主要是用来找到编译运行Java程序的命令javac和java命令）

3，Java标识符

4，变量和常量

5，Java数据类型

6,运算符

7,循环语句

8,函数（方法）

8.1函数的重载

9，数组

相关文章

大数据新鲜干货，一起学习吧

JavaSE 基础学习之五 —— IO 操作 (java. io

JAVA(1) 基础与环境配置

简述JavaEE学习流程

JavaSE基础

JAVASE基础

JavaSE基础

JavaSE基础

Javase基础

JavaSE基础

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaSE基础

1，Java虚拟机以及jdk和jre的介绍

2，Java环境变量 （主要是用来找到编译运行Java程序的命令javac和java命令）

3，Java标识符

4，变量和常量

5，Java数据类型

6,运算符

7,循环语句

8,函数（方法）

8.1函数的重载

9，数组

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

2，Java环境变量（主要是用来找到编译运行Java程序的命令javac和java命令）