JAVA基础01-基本数据类型,流程控制,Scanner类的使用,基本类型,数组结构

已于 2023-07-12 00:45:36 修改
阅读量421 收藏 1
点赞数
分类专栏： JAVA基础 文章标签： java
于 2020-06-24 17:54:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44748289/article/details/106948964
版权

远山

java 开发环境配置 及java的三个版本

三个版本 JAVAME \JAVASE \JAVAEE

JAVVAME :嵌入式开发(手机\小家电…)

JAVASE: 标准版(桌面程序,控制台开发…)

JAVAEE: E企业级开发(web端,服务器开发…)

JDK\JRE\JVM

JDK

JDK: Java Development Kit

java 开发者工具, 包括JRE 和 JVM

还包括: java \ javac \ javadoc \ jar

​ java :运行

​ javac: 编译工具

​ javadoc: 可以变异成文档

​ jar: 可以打包发布

JRE: Java Runtime Environment :java运行时环境

包含JVM

JVM: Java Virtual Machine

​ java虚拟机,跨平台的保证, 两种运行方式: 编译型, 解释型

JAVA开发环境搭建

卸载

  1. 删除java 的安装目录
  2. 删除JAVA_HOME
  3. 删除path 下面的java目录
  4. doc 窗口 java -version 查看是否卸载

安装JDK

  1. 百度直接搜索JDK8 , 找到下载地址
  2. 同意协议,登陆
  3. 查看电脑版本信息 ,下载响应版本
  4. 双击.exe 安装
  5. 记住安装路径
  6. 配置环境变量
    1. 我的电脑右键点击属性 ->高级系统设置
    2. 点开,找到环境变量点击去
    3. 在系统变量点击新建, 变量名字 JAVA_HOME ,变量值,找到jdk安装路径
    4. 配置path 变量-点击编辑 新建 %JAVA_HOME%\bin %:代表引用的意思
    5. 一路确定, 然后doc命令 java -version

notepad++下载

Hello World

  1. 新建一个文件夹.

  2. 新建个java文件, 新建一个txt 修改后缀为.java

  3. notePad 打开 编写代码

    public class  HelloWorld{
	public static void main(String[] args){
		System.out.print("Hello World");
	}
}

  4. javac 编译HelloWorld.java

  5. java HelloWorld 运行

JAVA程序运行机制编译型和解释型

编译型 compile

​ 编译器:编译成JVM 认识的语言

解释型

​ 解释器:解释成计算机可运行的语言

java基础知识

01注释

java中注释有三种:

  • 单行注释

    • //注释

  • 多行注释

    • /*多行注释*/

  • 文档注释

    • /**
*@Description HelloWorld
*
*
*
*文档注释*/

02 标识符

关键字

abstractassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplementsimport
instanceofintinterfacelongnative
newpackageprivateprotectedpublic
returnstrictfpshortstaticsuper
switchsynchronizedthisthrowthrows
transienttryvoidvolatilewhile

03数据类型

  • 强类型语言

    • 要求变量的使用要严格符合规定,所有变量必须先定义后使用

  • 弱类型语言

  • Java的数据类型分为两大类

    • 基本类型(primitive type)

      • 数值类型
        • 整数类型
          • byte 占1个字节范围 -128~127
          • short占2个字节范围：-32768~32767
          • int 占4个字节范围： -2147483648~2147483647（正负21亿）
          • long占8个字节： -9223372036854775808~9223372036854775807
        • 浮点类型
          • float占四个字节
          • double占8个字节
        • 字符型char占2个字节
      • boolean类型： 占1位其值只有true何false两个

    • 引用类型(reference type)

      • 类

      • 接口

      • 数组

      • 。。。

什么是字节

  • 位（bit):是计算机内部数据存储的最小单位，11001100是一个八位二进制数；

  • 字节（byte):是计算机中数据处理的基本单位，习惯上用大写B来表示1B(byte字节)=8bit（位）；

  • 字符：是指计算机中使用的字母、数字、字和符号

    1bit=1位

    1Byte表示一个字节8bit=1B

    1024B=1KB

    1024KB=1M

    1024M=1G

    …

04类型准换

由于java是强类型语言,所以要进行有些运算的时候,需要用到类型转换.

由低->高

byte、short、char->int->log->float->double

运算时，不同数据类型先转换成相同后再进行运算。

//强制类型转换会导致内存溢出问题
int i = 128;
byte b = (byte)i; // - 128  byte 最大是127
 //1.不能对布尔值进行转换
 //2. 不能把对象转换为不相干的类型; 
 //3. 在把高容量转换到底容量的时候,强制转换
 //4. 转换得时候可能存在内存溢出或者精度问题!

强制转换：由高到低需要强转；

自动转换：由低到高自动转换；

//java7(jdk7)新特性数字之间可以使用‘_'来分割
int i = 100_000_000; // 100_000_000=100000000

public static void t1() {
    int money = 1_000_000_000;
    int year = 20;
    int total = money * year;
    // 输出 ‘-1474836480’ 原因 int最大正负21亿 计算的时候溢出
    System.out.println(total);
    long total1 = money * year;
    // 输出 ‘-1474836480’ 原因 int最大正负21亿 计算的时候溢出 money * year在计算之前系统自动转换成int后复制给total1所以同样存在问题
    System.out.println(total1);
    long total2 = money *(long)year;
    //输出正确 ‘20000000000’ 需要注意计算之前需要强转
    System.out.println(total2);
}

05: 变量,常量,作用域

变量

  • 变量是什么:就是可以变化的量.

  • java是一种强类型的语言,每个变量都必须声明变量名,变量类型和作用域.

  • java变量是程序最基本的存储单元,其要素包括变量名,变量类型和作用域.

    type varName = [=value][{,varName[=value]}];
//数据类型  变量名 = 值 ;可以使用逗号来隔开声明多个同类型的变量

    注意事项

    • 每个变量都有类型, 类型可以是基本类型也可以是引用类型;
    • 变量名必须是合法的标识符.
    • 变量名是一条完整的语句,因此每一个声明都必须以分号结束

作用域

  • 类变量
  • 实例变量
  • 局部变量
public class Test01 {
    //类变量
    static String a  = "";
    //实例变量 ,从属于对象:如果不进行初始化, 这个类型的会有自己的默认值
    //布尔值: 默认是false;
    //除了 基本类型,其余数据类型都是null
    String s1 ;
    public static void main(String[] args) {
        //局部变量, 必须先声明在使用, 并且得初始化值;
        int  i  =10 ;
    }
}

常量

  • 常量(Constant):初始化(initialize)后不能改变值,不会变动值;

  • 也可以理解为特殊的变量,它的值一旦设定,在程序运行期间不能更改;

    public class Test02 {
    //修饰符, 不存在先后顺序    (静态常量)
    static final  double D =12.2;
    public static void main(String[] args) {
        System.out.println(D);
    }
}

  • 常量名一般用大写字符.

变量命名规范

  • 所有变量,方法,类名:见名知意
  • 类成员变量:首字母小写和驼峰原则:mothSala除了第一个单词以外后面的单词首字母大写
  • 局部变量: 首字母小写 + 驼峰原则
  • 常量: 大写字母 , 如果单词比较多中间+下划线: MAX_SEX
  • 类名: 首字母大写和驼峰原则: 例:Test
  • 方法名: 首字母小写和驼峰原则: run(); testRun();

06:基本运算符

算数运算符关系运算符逻辑运算符位运算符扩展赋值运算符条件运算符赋值运算符
+:加>:大于&&:与&:与+=:加等于?=
-:减<:小于||:或者|: 或-=:减等于
*:乘>=:大于等于!:非^:异或*=:乘等于
/:除<=:小于等于!:取反/=:除等于
%:取余==:等于<<:左移 *2
++:自加 在前先自增!=:不等于>>:右移 /2
–:自减 在前先自减instanceof:是否属于某一个类型>>>

关于位运算符的介绍

 /*
    * A   = 0011  1100
    * B   = 0000  1101
    * -----------------------
    * A&B = 0000  1100  两1则1
    * A|B = 0011  1101  有1则1
    * A^B = 0011  0001  两个位置相同则为0 ,不同则为1
    * ~B  = 1111  0010  为0 则 1  为1 则零
    * --------------------------------------------
    * 面试题
    * 2*8  = 16怎么样做才能最快
    * 2*8 = 16 = 2*2*2*2
    * << 左移  *2
    * >> 右移  /2
    *
    * 0000 0000   ->0
    * 0000 0001   ->1
    * 0000 0010   ->2
    * 0000 0011   ->3
    * 0000 0100   ->4
    * 0000 1000   ->8
    * 0001 0000   ->16
    * */

07:自增自减运算符,初始math 类

Math类 :提供很多科学运算方法

08:逻辑运算符,位运算符

public static void main(String[] args) {
        // 与(and)   或(or)   非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b"  + (a&&b));// 有假则假   false
        System.out.println("a || b"  + (a||b));//有真则真    true
        System.out.println("!a && b"  + !(a&&b));//若果为真就是假  true
    }

09:三元运算符|算木运算符

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b;  //a =a+b
        System.out.println(a);//30

        int c = 20;
        int d = 10;
        c -= d; //c = c-d
        System.out.println(c);//10

        int e = 10;
        int f = 20;
        //字符串拼接  字符串在前面,拼接 , 字符串在后面先进行运算;
        System.out.println("" + e+f);//1020
        System.out.println(e+f+"" );//30

        //三元运算符
        // x?y y:z  如果结果为真则输出y  ,否则则输出z
        int score  = 60;
        String type = score < 60 ?  "不及格":"及格";
        System.out.println(type);//及格
    }

运算符的优先级 ()优先

10:java中的包机制

  • 为了更好的组织类,java提供了包机制,用于区别类名的命名空间.

  • 包语法格式为

  • package  pkg1[.pkg2.pkg3.....];
//卸载代码第一行

  • 一般使用公司域名到写作为包名: www.yuanshan.com -> com.yuanshan.项目名称(project)

  • 为了能够使用某一个包的成员,我们需要在java程序中明确导入该包,使用import 语句即可

  • import  com.yuanshan.project
//写在包名下面
import com.yuanshan.* 导入到yuanshan下面所有的包类

11:javaDOC 生成文档

  • javadoc 命令是用来生成自己的API文档的
  • 参数信息
    • @author 作者名
    • @version 版本号
    • @sine 知名需要 最早使用的jdk版本
    • @param 参数名
    • @return 返回值情况
    • @throws 异常抛出情况
javadoc -encoding UTF-8 setencoding UTF-8 类名

12:java流程控制01:用户交互Scanner 类

  • java提供了很多工具类, 其中java.util.Scanner 是java5 的新特性可以使用Scnner来获取用户的输入

  • 基本语法

  • Scanner s = new Scanner(System.in);

  • 通过Scnner类的next()与nextLine()方法来获取输入的字符串, 在读取前一般使用hasNext() 与hasNextLine()来判断是否还有输入的数据.

Scanner对象

  • next()

    1. 一定要读取到有效的字符后才可以结束输入.
    2. 对输入有效字符之前遇到的空白, next()方法会自动将其去掉.
    3. 只输入有效字符后将其后面输入的空白作为分隔符或者结束符.
    4. next()不能得到带有空格的字符串

  • nextLine():

    1. 以Enter 为结束符,也就是说nextLine()方法返回输入回车之前的所有字符
    2. 可以获取空白
public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请录入字符串!");
        if(scanner.hasNext()){
            String s =  scanner.next(); // hello o o o
            System.out.println("录入的字符串为:"+s);  //录入的字符串为:hell
        }
        //关闭资源节省空间
        scanner.close();
    }
 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请录入字符串!");
        if (scanner.hasNext()) {
            String s1 = scanner.nextLine(); //rwerewr  rwer
            System.out.println("录入的字符串为:"+s1); //rwerewr  rwer
        }
        //关闭资源节省空间
        scanner.close();
    }
 public static void main(String[] args) {
        Scanner scnner = new Scanner(System.in);
        System.out.println("请录入字符串!");
        String s =  scnner.nextLine(); //gfg gfd
        System.out.println("录入的字符串是:"+s); //gfg gfd
        scnner.close();
    }

13:Scanner 类的进阶使用

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //判断是否为整数
        System.out.println("请输入一个整数");
        if (scanner.hasNextInt()) {
            int i = scanner.nextInt();
            System.out.println("你录入的整数位:" + i);
        } else {
            System.out.println("你录入的不是整数");
        }
        System.out.println("请输入一个小数");
        //判断是否为小数
        if (scanner.hasNextFloat()) {
            float v = scanner.nextFloat();
            System.out.println("你输入的小数为:" + v);
        } else {
            System.out.println("你输入的不是一个小数");
        }
        //关闭资源
        scanner.close();
    }

public static void main(String[] args) {
        //我们可以输入多个数字,并求和与平均值,每输入一个数字按回车确认,通过输入非数字来结束输入King输出执行结果
        Scanner scanner = new Scanner(System.in);
        // 定义基准数;
        int sum = 0;
        // 定义计步器;
        int  num = 0;
        System.out.println("请录入整数以便求和");
        while(scanner.hasNextInt()){
            System.out.println("请录入第"+(num+1)+"整数");
            int i = scanner.nextInt();
            System.out.println("你输入的整数是"+i);
            num++;
            sum+=i;
            System.out.println("和是"+sum);
        }
        //关闭资源节省空间
        scanner.close();
    }

14:流程控制,顺序结构

  • JAVA的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行.

  • 顺序结构是最简单的算法结构;

    ​ 1 A

    ​ 2 |

    ​ 3 B

    ​ 4 ↓

    ​ 5 C

  • 语句与语句之间,框与框之间是按从上到下的顺序进行的,他是有若干个一次执行的处理步骤组成的, 他是任何一个算法都离不开的一种基本算法结构.

    public static void main(String[] args) {
        System.out.println("00001");
        System.out.println("00002");
        System.out.println("00003");
        System.out.println("00004");
        System.out.println("00005");
    }

15:java流程控制 : if选择结构

if选择结构

  • if 但选择结构

    • 很多时候回判断一个东西是否可行

    • 语法:

      if(布尔表达式){
	//如果表达式为true 将执行花括号内的语句，也就是此处
}

  • if 双选择结构

    • 相对于但选择,有时候我们还有更多的选择, 比如一个三叉路口,要么往左,要么往右

    • 语法

    • if(布尔类型){
	//如果为true 则执行
}else{
    //否则的话就位false此处语法执行
}

  • if 多选择结构

    • 有时候我们的选择情况不只有两种会有很多种这时候就会用到多选择结构

    • 语法

      if(布尔表达式1){
    //如果表达式1为true则执行
}else if(布尔表达式2){
    //如果表达式2为true则执行
}else if(布尔表达式3){
	//如果表达式3为true则执行
}else if(布尔表达式4){
    //如果表达式4为true则执行
}else{
    //以上都不成立则执行
}

  • 嵌套的if结构

    • 语法也性对简单,比较容易理解

      if(表达式1){
    
    if(表达式2){
        
    }else{
        
    }
}else{
    
}

      每个if语句最好跟一个else 提高程序的可读性

16:java流程控制switch 多选择结构

  • 多选择结构还有一个实现方式就是switch case 语句.
  • switch case 语句判断一个变量与一系列值中某个值是否相等,每一个值成为一个分支
  • switch 语句的变量类型可以是:
    • byte ,short, int , char
    • 从java1.7开始支持string类型
    • 同时case标签必须为字符串常量,或字面量
public static void t2() {
        int i = 2;
        switch (i) {
            case 1:
                System.out.println("1");
                break;
            case 2:
                /**
                 * i为2 但是未写'break' ,匹配成功会输出‘2’ 但是程序会继续往下执行
                 * ‘3’也会输出，‘3’有写 ’break‘ 输出‘3’后程序终止，如果‘3’没有
                 * ‘break' 则会导致’4‘也会输出， 这就是case穿透（switch穿透）
                 * 如果下面没有’break'则程序直接执行至default 会输出
                 * 2
                 * 3
                 * 4
                 * 其他
                 * 所有每个'case'都要习惯加上’break'避免switch穿透
                 */
                System.out.println("2");
                //break;
            case 3:
                System.out.println("3");
                break;
            case 4:
                System.out.println("4");
                break;
            default:
                System.out.println("其他");
        }

如果没有break 就会造成case穿透, 如果匹配到一个值相同,那么下面的语句也将输出,

default: 如果之前的都没有匹配到,那么会出处default 部分

17:循环结构

  • while 循环

    • while 是最基本的循环,他的结构为:

      while(布尔表达式(条件)){
		//循环内容
}

    • 只要布尔表达式为true, 循环就会一直执行下去

    • 大多数情况下不会都是会让循环停下来的, 我们需要一个让表达式失效的方法来结束循环.

    • 少部分的情况需要循环一直执行, 比如服务器的请求响应监听的

    • 循环条件一直为true 就会造成无限循环(死循环),正常的业务编码中尽量避免死循环,会直接影响程序的性能,造成程序卡死,崩溃

  • do . . while 循环

    • 对于while 而言 如果不满足条件就不会进入循环,但是有时候即使不满足条件我们也要执行一次

    • do … while 循环和while 循环类似, 不同的是, do … while 循环至少会执行一次.

    • do {
	//输出语句
}while(布尔表达式);

    • while 和do …while 的区别

      • while先判断后执行, do while 是先执行后判断
      • Do . … while 总是保证循环体会被至少执行一次, 这是他们的主要差别

  • for 循环

    • for 循环语句是支持迭代的一种通用结构, 是最有效, 最灵活的循环结构.

    • for 循环执行的次数是在执行前就已经确定的,

    • 语法

      for(初始化值;布尔表达式;更新){
    //代码语句
};

      最先执行初始化步骤,可以声明一种类型,但可以初始化一个或多个循环控制变量,也可以是空语句

      然后,检测布尔表达式的值,如果结果为true 循环体执行,如果为false , 循环终止, 开始执行循环体后面的语句,

      执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减)

      再次检测布尔表达式,循环上面的过程

      for(; ;){
 //死循环
}

  • 在java5 中引入了一种主要用于数组的增强for循环

    • 主要用于遍历数组与集合的

    • 语法格式

      for(声明语句:表达式){
    //代码句子
}

    • 声明语句:声明新的局部变量,该变量的类型

18 :break continue

  • break 在任何循环语句的主体部分,均可以用break 控制循环的流程, break用于强行退出循环,不执行循环中剩余的语句(break 语句也在switch 语句中使用)
  • continue 语句用在循环句体中, 用于终止末次循环过程, 即跳过循环体中尚未执行的语句,接着进行下一次是否循环的判定;
  • 关于goto 关键字
    • goto 关键字很早就在程序设计语言中出现,尽管goto 仍是java的一个保留字,但并未在语言中得到正式使用;java没有goto ,然而,在break 和continue这两个关键字身上,我们仍然能看出一些goto的影子–带标签的break 和continue
    • 标签, 是指后面跟一个冒号标识符.例如: label:
    • 对于java来说唯一用到标签的地方是在循环语句之前,而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环,由于break 和continue 关键字通常只中断当前程序,若随着同标签使用,他们就会中断到存在标签的地方.

19: java中的方法

  1. 什么是方法

    • java中方法是语句的集合,他们在一起执行一个功能

    • 方法包含于类或者对象中

    • 方法在程序中被创建,在其他地方被引用

    • 设计方法的原则:方法的本意是功能块, 就是实现某个功能的语句块的集合,我们设计方法的时候,最好保持方法的原子性,就是一个方法只完成一个功能,这样有利于后期的扩展
      格式:

    • //修饰符 返回类型  方法名  (参数列表)
public static int add(int a, int b){
    //返回值
    return a+b;
}

  2. 方法的定义及调用

    • java中的方法类似于其他语言中的函数, 是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法;

    • 方法包含一个方法头和一个方法体:

      • 修饰符:修饰符,这个是可选的,告诉编译期如何调用该方法, 定义了该方法的访问类型.

      • 返回值类型:方法可能会返回值, return Value Type 是方法返回值的数据类型,有些方法执行所需的操作,但没有返回值,在这种情况下, return Value Type 是关键字void

      • 方法名: 是方法的实际名称,方法名和参数表共同构成方法签名;

      • 参数类型: 参数像是一个占位符,当方法被调用时, 传递给参数, 这个值被成为实参或变量,参数列表是指方法的参数类型,顺序和参数的个数, 参数是可选的, 方法可以不包含任何参数.

        • 形式参数:在方法被调用时用于接收外接输入的数据
        • 实参:调用方法时实际传给方法的数据

      • 方法体:方法体包含具体的语句,定义该方法的实现功能

    • 方法的调用:

      • 调用方法:对象名.方法名(实参列表)
      • java 支持两种调用方法的方式,根据方法是否返回值来选择.
      • 放方法返回一个值的时候,方法调用通常被当做一个值,例如:
        int larger =max (20,50);
      • 如果方法返回值是void , 方法调用一定是一条语句.
      • 什么是值传递? 什么是引用传递;

  3. 方法的重载

    • 重载就是在同一个类中,有相同的函数名称,但是形参不同的函数,
    • 方法重载的规则:
      • 方法名必须相同.
      • 参数列表必须相同(个数不同,或类型不同,参数排列顺序不同等)
      • 方法的返回类型可以相同也可以不相同.
      • 仅仅返回值类型不同不足以成为方法的重载;
    • 实现理论:
      • 方法名称相同是,编译期会根据调用方法的参数个数, 参数类型等去逐个匹配, 以选择对应的方法, 如果匹配失败, 则编译期报错;

  4. 命令行传参

    略

  5. 可变参数

    • java1.5开始, java支持传递同类型的可变参数给一个方法.

    • 在方法声明中,在指定参数类型后加一个省略号(…).

    • 一个方法中只能指定一个可变参数, 他必须是方法的最后一个参数, 任何普通的参数必须在它之前声明

      /**
*调用 时 可以传递 1、2、3、4... 参数
* t3(1,2,3);
* t3(1,2,3,4,5,6);
*t3(1,2,3,7,8,9,0);
*/
//方法
public static void t3(int... ints) {
        if (ints.length==0) {
            System.out.println("一个没有");
            return;
        }
        for (int i = 0; i < ints.length; i++) {
            System.out.println(ints[i]);
        }
    }

  6. 递归

    • A方法调用B方法,很容易理解
    • 递归就是:A方法调用A方法, 自己调用自己
    • 利用递归可以用简单的程序来解决一些复杂的问题, 他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解, 递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量, 递归的能力在于用有限的语句来定义对象的无限集合
    • 递归结构包括两部分
      • 递归头:什么时候不调用自身方法, 若果没有头,将陷入死循环.
      • 递归体: 什么时候需要调用自身方法;
 /**
  * 调用：t4(0)
  * 输出
  * 5
  * 4
  * 3
  * 2
  * 1
  * @param i
  * @return
  */
 public static int t4(int i) {
     //结束条件
     if (i==5) {
         return i;
     }
     //每次i自增1
     i++;
     //递归调用
     t4(i);
     System.out.println(i);
     return  88888888;
 }

注意看输出顺序。

20 :数组

  1. 数组的概述

    1. 数组是相同数据类型的有序集合.
    2. 数组描述的是相同类型的若干个数据, 按照一定的先后次序排列组合而成,
    3. 其中每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问他们.

  2. 数组声明创建

    1. 首先必须声明数组变量,才能在程序中使用数组,下面是基本语法

      dataType[] arrayPefVar; //首选方法 
dataType  array[]; //效果一样,但是不推荐

    2. java语言中使用new操作符来创建数组, 语法如下:

      dataType[]  array  = new dataType[长度]

    3. 数组的元素是通过索引访问的, 数组索引从0开始.

    4. 获取数组的长度, arr.length

    内存分析:

    数组 | 1 |2|3|4|5|

    下标 0 1 2 3 4

    三种初始化

    int[] arr1 = new int[10];
int[] arr2 = {1, 2, 3};
int[] arr3 = new int[]{1,23,4};

    数组的四个基本特点:

    • 其长度都是确定的, 数组一旦被创建,他的大小是不可改变的.
    • 其元素 类型是相同的,不能是混合类型,
    • 数组中的元素可以是任何数据类型, 包括基本类型和引用类型.
    • 数组变量属于引用类型,数组也可以看做是对象,数组中的每个元素相当于对象中的成员变量;, 数组本身就是对象, java中的对象是在堆中的, 因此数组无论保存原始数据类型还是其他对象类型, 数组对象本身都是在堆中的;

  3. 数组使用

    • forEach 增强for循环遍历
    • 数组当做入参
    • 数组当做返回值
    • 数组的操作…反转数组

  4. 多维数组

    • int a[][] = new int[2][6]

    • 数组里面套数组

  5. Arragys 类

    • 数组的工具类, java.util.Arrays
    • 由于数组对象本身并没有什么方法可以供我们调用,但是API中提供了一个工具类Arrays供我们调用,从而可以对数组对象进行一些基本的操作.
    • 查看JDK帮助文档
    • Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而不用使用对象来调用(不用 不是 不能)
    • 具有以下常用功能
      • 给数组赋值:通过fill方法.
      • 非数组排序,通过sort 方法, 按升序
      • 比较数组:通过equals 方法比较数组中的元素是否相等.
      • 查找数组元素:通过binarySearch 方法能对排序好的数组进行二分查找法操作

  6. 冒泡排序

    • 冒泡排序是最为出名的排序算法之一,总共有八大排序算法;

    • 两两比较

    • 冒泡的代码还是相当简单的, 两层循环,外层冒泡轮数, 里层依次比较;

    • 当我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n2)

    •     public static void main(String[] args) throws InterruptedException {
         int[] array = {2, 4, 7, 3, 1, 7457, 32, 11, 754, 321, 523};
         int[] sort = sort(array); ///[1, 2, 3, 4, 7, 7457, 32, 11, 754, 321, 523]
         System.out.println(Arrays.toString(sort));
     }
     public static int[] sort(int[] array) throws InterruptedException {
         int temp = 0;
         for (int i = 0; i < array.length-1; i++) {
             for (int j = 0; j < array.length-i; j++) {
                 if (array[j] > array[i]) {
                     temp = array[i];
                     array[i] = array[j];
                     array[j] = temp;
                 }
             }
         }
         return array;
     }

  7. 稀疏数组

    • 当一个数组中大部分元素为0,或者为同一个值的数组是,可以使用稀疏数组来保存该数组

    • 稀疏数组的处理方式是:

      • 记录数组一共有几行几列,有多少个不同值
      • 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

    • 如下图:左面是原始数组,右面是稀疏数组;

      |下标行列值
      00022|0142
      01100|12211
      000-6|234-6
      91000|34191
       public static void main(String[] args) {
        /**
         * 首先创建一个二维数组.类似于五子棋棋盘  我们用 0 代表空格 用 1 代表黑子, 用 2 代表白子  长宽  为11行 11列
         */
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=================================");
        //将原来的数组压缩为稀疏数组
        //获取原来数组的有效值的个数
        int count = 0 ;
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length; j++) {
                if (array[i][j] != 0) {
                    count ++;
                }
            }
        }
        //创建稀疏数组
        System.out.println("有值的个数:"+count);
        int[][] array1 = new int[count+1][3];
        array1[0][0] = 11;
        array1[0][1]  = 11;
        array1[0][2]  = count;
        int count1 = 0;
        //将原来数组有值的地方赋值到稀疏数组相应的坐标
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length; j++) {
                if (array[i][j] != 0) {
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("将稀疏数组还原回原来的数组");
        int[][] array3 = new int[array1[0][0]][array1[0][1]];
        for (int i = 1; i < array1.length; i++) {
            array3[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        System.out.println("输出还原数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
java中自加（++）和自减（--）运算符
weixin_57283233的博客
04-24 1325
java中自加自减运算符
用Scanner输入一个数组
Ineedmoney2333的博客
10-13 5294
public static void scanArray(){ System.out.println("\r请输入数组:"); Scanner scan = new Scanner(System.in); // 定义一个数组用于保存输入的数据 String[] arr = new String[10]; for (int i = 0...
JAVA学习笔记
丰旭的博客
01-29 1557
第一章 IDEA基本配置和快捷键 IDEA快捷键 快捷键 功能 ctrl+Y 删除当前行 ctrl+D 复制当前行 Alt+Enter 导入包自动修正代码 Ctrl+Alt+L 格式化代码 Ctrl+/ 单行注释，再按取消 ctrl+shift+/ 选中代码注释，再按取消 Alt+Ins 自动生成代码：如toString,set,get等方法 Alt+S...
Java学习笔记
weixin_43888112的博客
03-05 418
** 【JAVA】学习笔记**（12.04） 代码执行的过程 Java程序的开发周期包括编译、下载、解释和执行几个部分。 1.先编写java代码。 2.编译，编译Java代码成字节码（.class文件）。 3.字节码被装入内存。 4.进入虚拟机被解释器执行或者被即时代码发生器有选择的转换成机器码执行 打开CMD的方式 1.开始 + 系统 + 命令提示符 2.Win + R 输入cmd打开控制台 3.在任意的文件夹下面，按住shift + 鼠标右键
Java基础语法测试-基础数据类型-注解-数组-inet-反射-oop-Java代码实现
03-09
内容概要：通过带着读者编写Java基础语法测试代码，理解基础数据类型-注解-数组-inet-反射-oop-Java代码实现过程和测试代码 适合人群：初学java语法入门测试代码 能学到什么：①注解、数组、数据类型、inet、method...
Java基础教程：从基本数据类型到数组操作与面向对象实现
最新发布
09-23
内容概要：本文档详细讲解了 Java 基础知识，涵盖了基础数据类型的定义以及它们在内存中的存储方式。文中探讨了不同类型数据的应用范围，并引入数组的创建与应用实例——如动态接收输入并完成数组求和。另外，在面向...
Java实验二-基本数据类型和数组.doc
06-20
【Java实验二-基本数据类型和数...总的来说，这个实验旨在帮助学生掌握Java的基础知识，包括基本数据类型、数组、类型转换以及输入输出操作。通过实际编写和运行代码，学生能够更深入地理解这些概念，并提高编程技能。
Java基础编程代码-包含main()、输入输出、基本数据类型、数组、基本排序算法等的代码
03-20
下面将对 Java 基础编程代码进行详解，包括 main() 函数、输入输出、基本数据类型、数组和基本排序算法等。 main() 函数 在 Java 程序中，main() 函数是程序的入口点，是程序执行的开始。main() 函数的定义格式...
Java语言程序设计：JAVA_2-基本数据类型、枚举类型和数组.ppt
06-01
在Java中，数组是对象，但其元素可以是基本数据类型。创建和访问数组的语法是固定的，例如`int[] array = new int[10];`。 6. **枚举类型（enum）**： - Java 5引入了枚举，它允许创建一组固定的常量，常用于表示...
最大子序列和
y114102的博客
12-16 306
最大子序列和 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例: 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 暴力循环 算法的主要思想是求出所有的连续子序列的和，然后取最大值即可。 public static int base(int[] array) { int max = 0; for (int i = 0; i < array.leng
java基础 day14 数组 二维数组 冒泡排序 例题（正则表达式）
龙龙的博客
02-28 395
数组：
定义一个数组，数据类型为int，通过键盘输入10个数组元素，编程实现由小到大排序。
肥学的博客
04-01 3931
import java.util.*; public class goodstudy{ public static void main(String [] args){ Scanner sc=new Scanner(System.in); String a=sc.nextLine(); String arry1[]=a.split(" "); int arry[]=new int[arry1.length]; for(i
定义一个有10个元素的double型数组，然后从数组的最后一个元素倒着输出到第0个元素。并将数组元素进行累加。（java：数组和for循环）
热门推荐
我们一起
03-29 1万+
double array = new double[]{1.0,2.0,3,4,5,6,7,8,9,10}; int length = array.length; //定义数组长度 for(a=length-1;a&gt;=0;a--){ //既然是倒着输出那么肯定是从大到小 System.out.print(array[a]) //下标比值要小一位 a=10-...
java基础03
jerry_chen0126的博客
03-18 351
java基础03 流程控制 1、用户交互：Scanner 之前我们学的基本语法并没有实现程序和人的交互，Java给我们提供了一个工具类，可以获取用户的输入java.util.Scanner是Java5的新特征，我们通过Scanner类来获取用户的输入。 基本语法 Scanner s = new Scnner(system in); 通过Scanner类的 next()与 nextLine()方法获取用户的字符串，读取前一般用hasNext()与hasNextLine()判断是否还有输入的数据。
Java如何使用Label标识符
Canon
04-19 829
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Java基础 实验一：简单数据类型和流程控制
YDDUONG的博客
11-07 2589
1．实验目的 掌握标识符的定义规则、表达式的组成、各种数据类型及其使用方法、各种运算符的使用及其优先级控制。掌握分支结构，循环结构，continue，break，语句标号等内容。 2．实验内容 （1）输入一个三角形的3个边长，检查是否能构成一个直角三角形。 （2）任意从键盘输入一个0到9999之间的数，判断输入的数是几位数。 （3）铁路运货的运费与路程远近及货物的重量有关，设有如下的单位运费：...
Java编程：第二章-基本数据类型与数组详解
关键字在Java中具有特殊的含义，例如用于声明数据类型、控制流程、定义类和接口等。例如，`int`用于声明整型变量，`public`用于声明公共成员，`if`和`else`用于条件判断，`for`则用于循环控制。了解并熟练运用这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值