javaSE-(1)

最新推荐文章于 2022-04-09 22:04:36 发布

萨弗迪

最新推荐文章于 2022-04-09 22:04:36 发布

阅读量333

点赞数

本文链接：https://blog.csdn.net/qazsefbz168/article/details/79588935

版权

JAVA概述

JAVA发展史：

JAVA之父：詹姆斯.高斯林
SUN公司：斯坦福大学网络公司（2010-10-24被oracle收购）

JDK JRE JVM：

JDK: JAVA开发工具包，包含了JRE,编译工具，打包工具等。（安装了JDK就不用安装JRE了）。
JRE：JAVA运行环境，包含了核心类库和JVM。
JVM：JAVA虚拟机，JAVA程序需要运行在虚拟机上，虚拟机有各种平台的，因此JAVA语言可以跨平台。

注释概述

注释：

用于解释说明程序的文字。

注释分类：

单行注释: //
多行注释: /* */
文本注释: /** */

作用：

解释说明程序，帮助我们调试错误。

关键字

被JAVA语言赋予特定含义的单词。类和方法不能用关键字命名。

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表是其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块(return前执行)
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

关键字特点：

字母全部小写，编译器颜色标记

Java中修饰符总结：

访问控制修饰符

作用：用于控制被修饰变量、方法、类的可见范围.
public 的访问级别是最高的，其次是 protected、默认和 private.
成员变量和成员方法可以处于4个访问级别中的一个：公开、受保护、默认或私有.
存在继承关系时，父类不可以是 private，因为子类无法继承
顶层类可以处于公开或默认级别，顶层类不能被 protected 和 private 修饰.
局部变量不能被访问控制修饰符修饰 .
下图是在不同情况下各种权限修饰符的作用范围:

总结：在不同包下面能够访问的权限修饰符只有： pulbic 与protected，但是 protected 必须要有继承的关系才能够访问。
abstract 修饰符

抽象类不能被实例化.
抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象方法.
如果子类没有实现父类中所有的抽象方法，子类也必须定义为抽象类.
抽象类不能被定义为 private、final、和 static 类型.
没有抽象的构造方法.
抽象方法没有方法体,如果一个方法没有方法体,那么该方法必须声明为抽象的方法.
非抽象类继承抽象类的时候,必须要把抽象类中的所有抽象方法实现.
final 修饰符

final 变量必须被显式初始化，并且只能被赋值一次值
final 修饰基本类型变量的时候, 该变量不能重新赋值
final 修饰引用类型变量的时候, 该变量不能重新指向其他对象
final 修饰的方法为最终的方法, 该方法不能被重写
private 类型的方法都默认为是final方法，因而也不能被子类重写
final 修饰的类为最终的类, 不能被继承
static 修饰符

如果声明了静态方法或变量,值是放在方法区，因为方法区是一个数据共享区;所以不管什么变量访问它,都是同一份.
在静态方法中不能直接访问实例方法和实例变量.
在静态方法中不能使用 this 和 super 关键字.
静态方法不能被 abstract 修饰.
静态的成员变量可以使用类名或者是对象进行访问，非静态成员变量只能使用对象进行访问.
静态函数可以直接访问静态的成员,但是不能够直接访问非静态成员.，非静态函数可以访问静态和非静态成员.
当类被加载时，静态代码块只能被执行一次。类中不同的静态方法代码块按他们在类中出现的顺序被依次执行.
当多个修饰符连用时，修饰符的顺序可以颠倒，不过作为普遍遵守的编码规范，通常把访问控制修饰符放在首位，其次是 static 或 abstact 修饰符，接着就是其他的修饰符

注意：以下修饰符一起用是无意义的，会导致编译错误：
abstract 与 private
abstract 与 final
abstract 与 static

常量

常量概述：

在程序执行过程中，其值不能发生改变。
public static final String s="全局常量"；

常量分类：

字符串常量 - 双引号引起来
整数常量 - 所有整数
小数常量 - 所有小数
字符常量 - 单引号引起来
布尔常量 - true false
空常量 - null

变量

变量概述：

在程序执行过程中，在某个范围内，其值可以发生改变。

本质：

内存中的一小块区域

定义格式：

数据类型变量名 = 初始化值（ int i = 3; int a,b,c; )
局部变量使用前必须赋值
变量只在其所属范围内有效
同一区域不可以定义相同的变量名
整数默认是int类型，定义long类型要加L标识

JVM的内存划分：

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈：存储局部变量，运行时常量池的引用，方法返回地址。
堆：存储成员变量
Java中的堆是用来存储对象本身和数组的（数组的指针在java栈中）。
堆这部分空间是java垃圾回收的主要区域。
堆是被所有线程共享的，在JVM中只有一个堆。
方法区 (可以理解成class文件在内存中的存放位置)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

堆栈概述:

堆:

每个对象都有一个内存地址都有默认初始值:
byte,short,int,long默认值:0;
float,double:0.0;
char:\u0000;
引用类型:null;
boolean:false;
使用完毕会在垃圾回收器空闲的时候回收。

栈：

存储局部变量。
使用完毕立即被回收。

对象的创建过程

Person p= new Person("gao",24);这个简单的语句会涉及到如下几个步骤：
1，由于是要创建Person类对象，java虚拟机（JVM）先去找Person.class文件，如果有的话，将其加载到内存。
2，将类型信息（包括静态变量，方法等）加载进方法区。
3，执行该类中static代码块，如果有的话，对Person.class类进行初始化。
4，到这时才进行堆内存空间的开辟，并为对象分配地址。
5，在堆内存中建立对象的成员属性，并对其进行初始化（先进行默认初始化再进行显示初始化。）
6，进行构造代码块的初始化，由此看出构造代码库初始化的优先级要高于对象构造函数的初始化。
7，对象的构造函数进行初始化。

8，将堆内存中的地址赋给栈内存中的p变量。

数据类型

计算机存储单元

计算机存储设备的最小信息单元叫“位（bit）”
计算机最小的存储单元叫“字节（byte）” 一般用B表示。
1B = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB

数据类型概述和分类

分为基本数据类型和引用数据类型

引用数据类型：三种：数组，类，接口（String属于引用数据类型中“类”的范畴。只有引用类型才能使用占位符null）

基本数据类型：四类八种

四类	八种	字节数	数据表示范围
整	byte	1	-128～127
	short	2	-32768~32767
	int	4	-2147483648~2147483648
型	long	8	-2^63~2^63-1
浮点	float	4	-3.403E38～3.403E38
型	double	8	-1.798E308～1.798E308
字符型	char	2	表示一个字符如’2’
布尔型	boolean	1/8	true or false

整数默认是int类型，定义long类型要加L标识
小数默认是double,定义Float类型要加F标识
1：java开发过程中整型用int、小数用double、布尔用boolean；boolean类型不能强制转换为其它类型
2：类型转换都是小范围向大范围转换，大范围往小范围转化需要用到强制转换；
例如：(1)int a=12;double b=a;(2)double a=3.0;int b=(int)a;
3:long,byte,char等很少用到，一般在数据处理的时候会用到；
4：int跟char之间的转换是通过ASCII转化的；
例如：char a ='A';int b=a;System.out.prientln(b);最后输出的结果为65；

基本数据类型的封装类：

数据类型	封装类
boolean（布尔型）	Boolean
byte（字节型）	Byte
char（字符型）	Character
short（短整型）	Short
int（整型）	Integer
long（长整型）	Long
float（浮点型）	Float
double（双精度浮点型）	Double

封装类为各个数据类型提供一些数据的操作方法，可以直接使用；

例如String跟int的互相转化：

String a = "21";int b = Integer.parseInt(a);//String 转int。

int a = 21; String b = String.valueOf(a);//int转String。

自动装箱：把基本的数据类型转化为包装类

Integer i=10; 整数默认为int , 实际执行了 Integer i = Integer.valueOf(10);

自动拆箱：把包装类转化成基本数据类型

int a = i ; 实际执行了 int a = i.intValue;

标识符

作用：

给包，类，方法，变量等起名字。

组成规则：

由字符，下划线，$组成。

注意事项：

不能以数字开头
不能是关键字

命名原则：

见名知意

数据类型转换

隐式数据类型转换：

取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算。

强制数据类型转换：大范围往小范围转化需要用到强制转换

强制转换格式： b= (byte)(a + b);

注意事项：

如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同

运算符

对常量和变量进行操作的符号成为运算符
用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式
常用运算符：算术运算符关系运算符赋值运算符逻辑运算符三元运算符

算术运算符：

取余和除法的区别

%：取余运算符。得到的是两个相除数据的余数。
/:除法运算符。得到是两个相除数据的商

++ –详解

++,–运算符：对变量做加1或者减1的操作。
++或者–既可以放在变量的后面，也可以放在变量的前面。
单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。
参与运算的时候：
如果++或者–在变量的后面，先拿变量参与操作，后变量做++或者–
如果++或者–在变量的前面，先变量做++或者–，后拿变量参与操作。
赋值运算符：
基本的赋值运算符：=
扩展的赋值运算符：+=,-=,* =,/=,%=
+=: a+=20;相当于a = (a的数据类型)(a + 20)

关系运算符：

==,!=,>,>=,<,<=
关系运算符的结果都是boolean型，也就是要么是true，要么是false

逻辑运算符：

&,|,^,!,&&,||

注意事项：

逻辑运算符一般用于连接boolean类型的表达式或者值。
表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b(条件表达式)

总结：

运用：

&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
!逻辑非:非false则true，非true则false。

&&与&的区别：

最终结果一样。
&&具有短路效果。左边是false，右边不执行。
&是无论左边是false还是true,右边都会执行

||和|的区别：

最终结果一样
||具有短路效果.左边是true,右边不执行
|是无论左边是false还是true,右边都会执行

三元运算符：

关系表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；

简单的键盘录入：

import java.util.Scanner;   //导包
public class ScannerTest {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);

        // 接收数据
        System.out.println("请输入第一个数据：");
        int a = sc.nextInt();

        System.out.println("请输入第二个数据：");
        int b = sc.nextInt();

        // 对数据进行求和
        int sum = a + b;
        System.out.println("sum:" + sum);
    }
}

选择流程控制语句

顺序结构概述：

是程序中最简单最基本的流程控制，没有特定的语法结构，依照代码的先后顺序，依次执行，程序中大多数代码都是这样执行的。

if语句的格式

格式一

if(关系表达式){语句体}

格式二

if(关系表达式){语句体}else(语句体)

格式三

if(关系表达式){语句体}else if(关系表达式){语句体}else{语句体}

if语句实现获取三个数据排列顺序

1.键盘录入三个整数，按照从小到大的顺序输出
2.如果用户输入的是3 2 1，程序运行后打印格式”按照从小到大排序后的顺序为：1 2 3”

import java.util.*;
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int a = s.nextInt();
        System.out.println("请输入第二个整数：");
        int b = s.nextInt();
        System.out.println("请输入第三个整数：");
        int  c = s.nextInt();
        int temp;
        if(a < b){
            temp = a;
            a = b;
            b = temp;
        }
        if(a < c){
            temp = a;
            a = c;
            c = temp;
        }
        if(b < c){
            temp = b;
            b = c;
            c = temp;
        }
        System.out.println(c+"-->"+b+"-->"+a);
    }

switch语句的格式

格式:

 swith(表达式){   
   case 值1:
      语句体;
      break;
   case 值2:
      语句体;
      break;
   default:
     语句体;
     break;   
 }
 ```
### 格式解释:
- switch表示这是switch语句
- 表达式的取值：byte,short,int,char,String (不能取小数)
- JDK5以后可以是枚举
- JDK7以后可以是String
- case后面跟的是要和表达式进行比较的值
- 语句体部分可以是一条或多条语句
- break表示中断，结束的意思，可以结束switch语句
- default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
### 执行流程:
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

### 例句:
``` JAVA
public class SwitchDemo {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //接收数据
        System.out.println("请输入一个数字(1-7)：");
        int weekday = sc.nextInt();

        //switch语句实现选择
        switch(weekday) {
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期日");
            break;
        default:
            System.out.println("你输入的数字有误");
            break;
        }
    }
}




<div class="se-preview-section-delimiter"></div>

循环流程控制语句

for循环格式和基本使用

格式:

for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
}

执行流程：

A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续

案例:

public class ForDemo {
    public static void main(String[] args) {
        //原始写法
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("-------------------------");
        //用循环改进
        for(int x=1; x<=10; x++) {
            System.out.println("HelloWorld");
        }
    }
}




<div class="se-preview-section-delimiter"></div>

while循环语句格式

格式:

基本格式
   while(判断条件语句) {
         循环体语句;
   }
扩展格式
   初始化语句;
   while(判断条件语句) {
         循环体语句;
         控制条件语句;
}




<div class="se-preview-section-delimiter"></div>

public class WhileTest {
    public static void main(String[] args) {
        //回顾for循环实现
        /*
        //定义求和变量
        int sum = 0;
        //获取1-100之间的数据
        for(int x=1; x<=100; x++) {
            //累加
            sum += x;
        }
        System.out.println("1-100的和是："+sum);
        */
        //while循环实现
        //定义求和变量
        int sum = 0;
        int x = 1;
        while(x<=100) {
            sum += x;
            x++;
        }
        System.out.println("1-100的和是："+sum);
    }
}




<div class="se-preview-section-delimiter"></div>

do…while循环的格式及基本使用

格式:

基本格式
   do {
         循环体语句;
   }while(判断条件语句);
扩展格式
   初始化语句;
   do {
         循环体语句;
         控制条件语句;
} while(判断条件语句);




<div class="se-preview-section-delimiter"></div>

案例:

public class DoWhileDemo {
    public static void main(String[] args) {
        //输出10次 HelloWorld
        /*
        for(int x=1; x<=10; x++) {
            System.out.println("HelloWorld");
        }
        */

        //do...while改写
        int x=1;
        do {
            System.out.println("HelloWorld");
            x++;
        }while(x<=10);
    }
}




<div class="se-preview-section-delimiter"></div>

三种循环的区别:

do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

案例:

/*
 * 三种循环的区别：
 *      A:do...while至少执行一次循环体
 *      B:for,while循环先判断条件是否成立，然后决定是否执行循环体
 *
 * for和while的小区别：
 *      for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。
 *      如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。
 *
 * 循环的使用推荐：
 *      for -- while -- do...while
 */
public class DoWhileDemo2 {
    public static void main(String[] args) {
        /*
        int x = 3;
        while(x<3) {
            System.out.println("我爱林青霞");
            x++;
        }
        System.out.println("--------------");
        int y = 3;
        do {
            System.out.println("我爱林青霞");
            y++;
        }while(y<3);
        */
        for(int x=1; x<=10; x++){
            System.out.println("爱生活，爱Java");
        }
        //这里的x无法继续访问
        //System.out.println(x);
        System.out.println("-----------------");

        int y = 1;
        while(y<=10) {
            System.out.println("爱生活，爱Java");
            y++;
        }
        System.out.println(y);
    }
}




<div class="se-preview-section-delimiter"></div>

控制循环语句

break的使用

break的使用场景和作用：

break的使用场景：在选择结构switch语句中。
在循环语句中，离开使用场景的存在是没有意义的。
break的作用：跳出单层循环。

案例：

public class BreakDemo {
    public static void main(String[] args) {
        //break;

        for(int x=1; x<=10; x++) {
            if(x == 3) {
                break;
            }
            System.out.println("HelloWorld");
        }
    }
}




<div class="se-preview-section-delimiter"></div>

continue的使用

continue的使用场景和作用:

continue的作用：单层循环对比break。

案例:

public class ContinueDemo {
    public static void main(String[] args) {
        //continue;

        for(int x=1; x<=10; x++) {
            if(x == 3) {
                //break;
                continue;
            }
            System.out.println("HelloWorld");
        }
    }
}




<div class="se-preview-section-delimiter"></div>

总结：

break退出当前循环
continue退出本次循环

- return退出当前方法

Random讲解

使用步骤:

导包:import java.util.Random;
创建对象:Random r = new Random();
获取随机数:int number = r.nextInt(10);
产生的数据在0到10之间，包括0，不包括10。
括号里面的10是可以变化的，如果是100，就是0-100之间的数据

案例:

import java.util.Random;
import java.util.Scanner;

/*
 * 猜数字小游戏案例
 *      系统产生一个1-100之间的随机数，请猜出这个数据是多少。
 * 分析：
 *      A:系统产生一个随机数1-100之间的。
 *          int number = r.nextInt(100) + 1;
 *      B:键盘录入我们要猜的数据
 *          用Scanner实现
 *      C:比较这两个数据(用if语句)
 *          大了：给出提示大了
 *          小了：给出提示小了
 *          猜中了：给出提示，恭喜你，猜中了
 *      D:多次猜数据，而我们不知道要猜多少次，怎么办呢?
 *          while(true) {循环的内容}
 */
public class RandomTest {
    public static void main(String[] args) {
        // 系统产生一个随机数1-100之间的。
        Random r = new Random();
        int number = r.nextInt(100) + 1;

        while(true){
            // 键盘录入我们要猜的数据
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字(1-100)：");
            int guessNumber = sc.nextInt();

            // 比较这两个数据(用if语句)
            if (guessNumber > number) {
                System.out.println("你猜的数据" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数据" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你,猜中了");
                break;
            }
        }
    }
}




<div class="se-preview-section-delimiter"></div>

数组

数组的定义

数组的概念:

数组是存储同一种数据类型多个元素的容器。（只能存单种类型）
数组既可以存储基本数据类型，也可以存储引用数据类型。

定义格式:

格式1：数据类型[] 数组名;
格式2：数据类型数组名[];
注意：这两种定义做完了，数组中是没有元素值的。

数组的初始化

初始化概述:

Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组的初始化方式：

动态初始化:初始化时只指定数组长度，由系统为数组分配初始值

格式：

数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。

举例：

int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化:初始化时指定每个数组元素的初始值，由系统决定数组长度

public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};

        //输出数组名和元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }




<div class="se-preview-section-delimiter"></div>

一维数组的使用

遍历方式：

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




<div class="se-preview-section-delimiter"></div>

取最值：

public class ArrayTest2 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12,98,45,73,60};
        //定义参照物
        int max = arr[0];
        //遍历数组，获取除了0以外的所有元素，进行比较
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        System.out.println("数组中的最大值是："+max);
    }
}




<div class="se-preview-section-delimiter"></div>

二维数组的使用

格式:

- 定义格式:数据类型[][] 数组名;
- 初始化方式:
- 数据类型[][] 变量名 = new 数据类型[m][n];
- 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
- 简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};




<div class="se-preview-section-delimiter"></div>

遍历:

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




<div class="se-preview-section-delimiter"></div>

Arrays工具类十大常用方法
0. 声明数组
[java] view plain copy
1. String[] aArray = new String[5];
2. String[] bArray = {"a","b","c", "d", "e"};
3. String[] cArray = new String[]{"a","b","c","d","e"};
1. 打印数组
[java] view plain copy
1. int[] intArray = { 1, 2, 3, 4, 5 };
2. String intArrayString = Arrays.toString(intArray);
4. // 直接打印,则会打印出引用对象的Hash值
5. // [I@7150bd4d
6. System.out.println(intArray);
8. // [1, 2, 3, 4, 5]
9. System.out.println(intArrayString);
2. 根据数组创建ArrayList
[java] view plain copy
1. String[] stringArray = { "a", "b", "c", "d", "e" };
2. ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
3. // [a, b, c, d, e]
4. System.out.println(arrayList);
3. 检查数组是否包含某个值
[javascript] view plain copy
1. String[] stringArray = { "a", "b", "c", "d", "e" };
2. boolean b = Arrays.asList(stringArray).contains("a");
3. // true
4. System.out.println(b);
4. 合并连接两个数组
[java] view plain copy
1. int[] intArray = { 1, 2, 3, 4, 5 };
2. int[] intArray2 = { 6, 7, 8, 9, 10 };
3. // Apache Commons Lang 库
4. int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);
5. 声明内联数组
[java] view plain copy
1. method(new String[]{"a", "b", "c", "d", "e"});
6. 用给定的字符串连结(join)数组
[java] view plain copy
1. // containing the provided list of elements
2. // Apache common lang
3. String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
4. // a, b, c
5. System.out.println(j);
7. 将ArrayList转换为数组
[java] view plain copy
1. String[] stringArray = { "a", "b", "c", "d", "e" };
2. ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
3. String[] stringArr = new String[arrayList.size()];
4. arrayList.toArray(stringArr);
5. for (String s : stringArr)
6. System.out.println(s);
8. 将数组转换为Set
[java] view plain copy
1. Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
2. //[d, e, b, c, a]
3. System.out.println(set);
9. 数组元素反转
[java] view plain copy
1. int[] intArray = { 1, 2, 3, 4, 5 };
2. ArrayUtils.reverse(intArray);
3. //[5, 4, 3, 2, 1]
4. System.out.println(Arrays.toString(intArray));
10. 移除元素
[java] view plain copy
1. int[] intArray = { 1, 2, 3, 4, 5 };
2. int[] removed = ArrayUtils.removeElement(intArray, 3);//创建新的数组
3. System.out.println(Arrays.toString(removed));
更多——转换int值为字节数组
[java] view plain copy
1. byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();
3. for (byte t : bytes) {
4. System.out.format("0x%x ", t);
5. }
Math 类的几个常用方法

floor ：返回不大于它的最大整数如, Math.(1.4) = 1 , Math.(-1.4) = -2

round：表示“四舍五入”，计算方法是 Math.floor(x+0.5), 即将原来的数字加上0.5后再向下取整，如, Math.round(11.5) = 12, Math.round(-11.5) = -11

ceil ：返回不小于它的最小整数如，Math.ceil(1.4) =2 , Math.(-1.4) = -1

min ：返回较小的数如，Math.min(1, 2) =1

max ：返回较大的数如，Math.max(1, 2) = 2

adb ：取绝对值如，Math.abs(-5) = 5

方法（函数）的概述及基本使用

方法：简单的说：方法就是完成特定功能的代码块

方法的格式：

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
            函数体;
            return 返回值;
}

修饰符 public static abstract final synchronized
返回值类型用于限定返回值的数据类型
方法名一个名字，为了方便我们调用方法
参数类型用于接收调用方法时传入的数据的类型
参数名用于接收调用方法时传入的数据的变量
方法体完成功能的代码
return 结束方法，把返回值带给调用者

定义方法注意事项:

返回值类型明确功能结果的数据类型
参数列表明确有几个参数，以及参数的类型
按照格式和两个明确来完成如下功能

调用方式:

单独调用：没有明确的返回值比如void类型方法的调用
输出调用
赋值调用

方法的重载：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载特点：

与返回值类型无关，只看方法名和参数列表.
在调用时，虚拟机通过参数列表的不同来区分同名方法.
参数列表不同:参数个数或者参数类型不同.

参数传递：

方法的参数是基本类型的时候：形式参数的改变不影响实际参数。
形式参数：用于接收实际数据的变量
实际参数：实际参与运算的变量

萨弗迪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

javaSE-(1)

JAVA概述

JAVA发展史：

JDK JRE JVM：

注释概述

注释：

注释分类：

作用：

关键字

关键字特点：

Java中修饰符总结：

常量

常量概述：

常量分类：

变量

变量概述：

本质：

定义格式：

JVM的内存划分：

堆栈概述:

堆:

栈：

对象的创建过程

数据类型

计算机存储单元

数据类型概述和分类

基本数据类型的封装类：

标识符

作用：

组成规则：

注意事项：

命名原则：

数据类型转换

隐式数据类型转换：

强制数据类型转换：大范围往小范围转化需要用到强制转换

强制转换格式： b= (byte)(a + b);

注意事项：

运算符

算术运算符：

取余和除法的区别

++ –详解

赋值运算符：

关系运算符：

逻辑运算符：

注意事项：

总结：

运用：

&&与&的区别：

||和|的区别：

三元运算符：

简单的键盘录入：

选择流程控制语句

顺序结构概述：

if语句的格式

格式一

格式二

格式三

if语句实现获取三个数据排列顺序

switch语句的格式

格式:

循环流程控制语句

for循环格式和基本使用

格式:

执行流程：

案例:

while循环语句格式

格式:

do…while循环的格式及基本使用

格式:

案例:

三种循环的区别:

案例:

控制循环语句

break的使用

break的使用场景和作用：

案例：

continue的使用

continue的使用场景和作用:

案例:

总结：