JavaEE入门级别最全教程1--初学者必看
导读
相信很多初入编程的小伙伴对于语言有种选择恐惧症，对于Java也不知怎么去学，这期文章J哥会给大家整理最适合小白学习的JavaEE教程。
大数据的概述
# 大数据与云计算的学习
概念:海量数据，具有高增长率、数据类型多样性、一定时间内无法使用常规软件进行捕捉、管理和处理的数据集合。
特征:4V特征(是大家普遍认可的)
大量
多样
高速
价值
# 大数据能做什么？
在海量的各种各样类型的价值密度低的数据中，我们要进行的是: 数据采集、数据存储、数据清洗、数据分析、数据可视化。这个过程就是大数据要做的主要事情。
# 使用语言
JAVA8稳定(最新14)
Write Once Run Anywhere (一次编译处处运行)
JDK 开发环境
JRE 运行环境
JVM 虚拟机Java基础
Java的数据类型分类
// 基本数据类型
整型
- 字节型:byte
- 短整型:short
- 整型:int
- 长整型:long
浮点型
- 单精度浮点型:float
- 双精度浮点型:double
字符型:char
布尔型:boolean
// 引用数据类型标识符
// 标识符，是由若干个字符组成的有序数列。在标识符中应该遵守的规则:
1.由字母数字下划线和$组成
2.不能以数字开头
3.不能与系统关键字或者保留字重名
// 命名规范(驼峰命名法)
1.望文之意
2.驼峰命名法(大驼峰命名法、小驼峰命名法)
- 首字母大写
- 除首单词除外
- 没有特殊说明默认用小驼峰命名法变量/常量
# 计算机内存中的一块存储空间，是存储数据的基本单元 值可以改变称之为变量 (年龄、体重) 值不可以改变称之为常量(一个人的出生日期) IDEA中操作了
类型转换
// 强制类型转换
// 自动类型转换
// 特殊说明:
1.byte short char 类型的数据在进行运算的时候会自动的转换为int类型
2.浮点型转整型 会舍弃小数点后面的所有内容 只保留整数部分常用运算符
// 算数 + - * / % ++ --
++自增运算符
位于变量后表示先取值再进行加1的操作
位于变量前表示先进行加1后取值的操作
--自减运算符
与++一致
++ 与 —— 的优先级最高
// 赋值运算符 =
可以和其他运算符组合成 组合运算符
组合运算符 隐性的包含了类型转换
// 关系运算符 > >= = < <= == !=
// 1.关系运算符的结果一定是布尔类型的
// 2.等值比较需要注意，使用的是双等号
// 逻辑运算符 & | ! ^ && || 对两个布尔值进行的运算
java python go javascript c
& and && && && 与 :逻辑与，两真即为真，任意一个为假，结果即为假 false
| or || || || 或 :逻辑或，两假即为假，任意一个为真，结果即为真 true
! not ！ ！ ！ 非 :逻辑非，非真即假，非假即真。
^ 异或 :逻辑异或，相同为假，不同为真。
&& 短路与，如果前面的结果可以决定整体的运算结果，后面的表达式不参与运算
|| 短路或，如果前面的结果可以决定整体的运算结果，后面的表达式不参与运算
javascript中逻辑运算符取决于右侧，右边为什么返回的值就为什么
// 位运算符
只能位于两个整型的运算
& 位与运算，对补码的每一位进行与运算
| 位或运算，对补码的每一位进行或运算
^ 位异或运算，对补码的每一位进行异或运算
~ 按位取反运算 包括符号位
<< 按左移运算
>> 按右移运算 最高位补符号位
>>> 无符号位右移运算 左侧补0 就是最高位补的不是符号位 而是0
符号 64 32 16 8421
0 (0 0 0) (0000) --> 源码直接这样写
补码:举例:
-45 = 32 + 8 + 4 + 1
1010 1101 源码
1101 0010 + 1 = 1101 0011 补码 向右移动两位 溢出的就不要了 1111 0100 11 --> 11舍
移动后的补码 : 1111 0100
再反转位源码 : 1000 1011 + 1 = 1000 1100
最终结果为 -12
在右移运算的时候，每像右移动一位，相当于除了一个2，但是这里遵循向下取整 11.25 = 12
面试题:
如何高效率的计算 2*8
2*8 是 2+了八次
8*2 是 8+8
2<<3 这个效率最高
// 三目运算符
表达式 :布尔结果表达式/布尔变量?值1 : 值2
如果问好前面的布尔值是true，整体的结果为值1。否则整体的结果为值2。
// 运算符的优先级
整体看:一元运算符(只能操作一个数据:+ - ++ -- ! ~)>二元运算符(可以操作两个数据:+ - * /)>三元运算符(三目运算符 ? :)
赋值运算符的优先级最低
算数运算符中: 乘除模 > 加减
逻辑运算符中: 与 > 或、异或
小括号的优先级最高流程控制
// 流程控制分类
顺序结构/分支结构/循环结构 --java
顺序结构/分支结构/循环结构 --C
顺序结构: 代码从上往下，逐行依次执行。是程序执行的默认结构
分支结构: 程序在某一个节点遇到了多种可能向下执行的可能性，根据条件，选择一个分支继续执行
循环结构: 某一段代码需要被重复执行多次。
// 分支流程控制-if/switch
// 第一种 if else
if (condition) { // condition 判断条件(布尔 boolean)
// 代码段1
}
else{
// 代码段2
}
// 第二种 if - else if
if(){
}else if(){
}...
else{
}
// switch
switch(变量){
case 值1{
// 分支语句1
}
case 值2{
// 分支语句2
}...
default:
}
// 实例
int season = 1;
switch (season) {
case 1:
System.out.println("春天");
break;
case 2:
System.out.println("夏天");
break;
case 3:
System.out.println("秋天");
break;
case 4:
System.out.println("冬天");
break;
default:
System.out.println("错误的季节");
}
switch具有穿透性:指的是，当switch的变量和某一个case值匹配上之后，将会跳过后续的case或者default的匹配，直接向后穿透。
为了杜绝穿透，可以使用关键字break;
// 循环流程控制-for/while
for(循环的起点、循环的条件、循环的步长){
// 这里的代码，将在循环条件成立的时候重复执行
// 这里 又叫 循环体
}
循环起点: 只会执行一次 通常用于定义一个用来控制循环的变量
循环条件: 布尔结果的表达式，当成立的时候，循环体执行
循环步长: 记录每次循环发生的变化，通常用于改变控制循环的变量的值
// while
while (循环条件){
// 循环体
}
// do-while
do {
// 循环体
} while (循环条件);
如果从一开始的条件都是不成立的，那么do-while比while循环多执行一次逻辑
// 两个关键字
break 无论循环条件是否成立，立即结束循环
continue 立即停止本次循环，立即进入下次循环
如果循环的次数是可预期的 推荐使用for循环
如果循环的次数是不可预期的，但是有明确的结束条件，推荐使用while循环
// 循环标签
OUTER: // 通过内部循环结束外部循环
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
if (j == 3) {
break OUTER;
}
System.out.println("i = "+ i + ", j = " + j);
}
}循环案例
// 输出0-100所有奇数和
int sum = 0;
for (int number = 1; number <= 100; number++) {
if (number % 2 != 0) {
// System.out.println(number);
sum += number;
}
}
System.out.println(sum);
// 打印九九乘法表
int line = 1;
for (; line <= 9; line++) {
for (int column = 1; column <= line; column++) {
System.out.print(column + "x" + line + "=" +column*line + " "); // java的print没有换行 println自带一个换行符
} // python 中print有换行 需要 print(公式,end="")
System.out.println();
}
// 百钱白鸡
// 已知 每只母鸡5元钱，每只公鸡三元钱，三只小鸡一元钱
// 有100元去买鸡，要求正好花完100元，且购买100只鸡
// 输出所有的购买方案
for (int m = 0; m <= 100 / 5; m++) {
for (int g = 0; g < 100 / 3; g++) {
for (int x = 0; x <= 100; x += 3) {
// 小鸡的数量是三的倍数
if (m * 5 + g * 3 + x / 3 == 100 && m + g + x == 100) {
System.out.println("可以买:母鸡" + m + "公鸡" + g + "小鸡" + x);
}
}
}
}方法
// 方法的概念
我们将需要被多次执行的逻辑包装起来，在需要的时候直接调用即可。
方法就是为了事项这个需求而存在的(使其可以重复调用、降低代码的冗余、提高代码的复用性与维护性)
// 方法的定义与调用
[访问权限修饰符][其他的修饰符]返回值类型 方法名称([参数列表]){
方法体
}
public class FirstMethod {
public static void main(String[] args) {
// 访问权限修饰符:访问权限修饰符
// 其他修饰符: static
// 返回值类型: void
// 方法的名字: 小驼峰命名
// 小括号里面写参数列表
print(); // 调用方法
}
public static void print() { // 如果需要这个方法中的逻辑被执行，则需要进行方法的调用
// 方法体
System.out.println("This is my first method");
}
}
·方法是定义在类的内部的，与main函数并列(方法中不允许套用方法)
访问权限修饰符
// 方法的参数
调用方法时，传入的数据被称为 参数(定义在小括号中)
形参: 定义方法时定义的参数
实参: 需要传的值
传参: 实参给形参赋值-->传参
// 方法的返回值
函数调用时，一些情况下无需返回结果;另一些情况下则必须有返回值
return 关键字:表示方法执行的结果；方法的结束。
public class ReturnType {
public static void main(String[] args) {
System.out.println("和为:" + add(1, 2));
}
public static int add(int num1, int num2) { // int 返回值类型
return num1 + num2;
}
}
// 方法的重载
在一个类的方法中，如果多个方法满足如下条件，则他们之间的关系就是重载
·方法名相同
·参数不同
~参数不同，体现在参数的数量不同或者参数的类型不同 (方法的入口不同)
注意: 方法的重载与返回值没有关系！
public class Overload {
public static void main(String[] args) {
add();
add(2);
add(3, 4);
add("aa");
}
public static void add() {
System.out.println("无参数");
}
public static void add(int num1) {
System.out.println("add(int)");
}
public static void add(int num1, int num2) {
System.out.println("add(int int)");
}
public static void add(String s) {
System.out.println("add(String)");
}
}
// 方法的递归
递归，是一种程序设计的思想。在解决问题的时候，可以将问题拆分成若干个小问题。通过解决这些小问题，逐渐解决这个大问题。
package com.laity.basicSyntax.method;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.method
* @date Date : 2021年11月12日 23:36
* @Description: 方法的递归
*/
public class Method2 {
public static void main(String[] args) {
// multiply(9);
System.out.println(multiply(10));
System.out.println(sum(100));
}
/**
* /** 按ctrl + 回车
* 计算一个数字的阶乘
*
* @param num 需要计算阶乘的数字
* @return 计算的结果
*/
public static int multiply(int num) {
// 设置出口条件
if (num == 1) {
return 1;
}
// 递进与回归(自己调用自己)
return num * multiply(num - 1);
}
public static int sum(int n) {
if (n == 1) {
return 1;
}
return n + sum(n - 1);
}
}数组
// 概念：一组连续的存储空间，存储多个相同数据类型的值(是一个数据容器)
特点:类型相同、长度固定。
// 数组的声明 (注释:以后只要看到 关键字new 都是在堆上开辟空间)
int [] array = new int[5]; // int[5] 表示array这个数组存储的容量为5
数组中的数据默认值为:
整型:0
浮点型:0.0
字符型:'\u0000'
布尔型:false
引用数据类型:null
public class Array1 {
public static void main(String[] args) {
// 前言:使用[]表示一个数组，中括号前写数组中可以存储的数据类型
// 1.声明一个数组
// 2.数组的实例化:在为数组分配内存空间，并且分配数组中初始的值
// new： 为数组开辟空间，需要使用关键字new
// 实例化的同时，指定这个数组的长度
// 数组中的数据默认值为:
int[] array = new int[5]; // int[5] 表示存储的容量为5
// 实例化数组的同时，指定这个数组中存储的数据
// 此时这个数组中，默认存储了5个数据，也就是说数组的长度为5
int[] array2 = new int[]{1, 2, 3, 4, 5};
// 省略new int[]
int[] array3 = {1, 2, 3, 4, 5};
}
}
// 访问数组中的元素
public class Array2 {
public static void main(String[] args) {
// 1.实例化一个数组
int[] array = {1, 2, 3, 4, 5};
// 2.用里面的元素时，两种操作:读和写
int a = array[2];
System.out.println(a);
// 3..修改数组中的元素
array[3] = 100;
System.out.println(array[3]);
}
}
// 数组的遍历
就是按照数组中元素存储的顺序，依次拿到数组中的每一个元素。
package com.laity.basicSyntax.day1.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day1.bArray
* @date Date : 2021年11月13日 9:54
* @Description: 数组的遍历
*/
public class Array3 {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i = 0; i <= 9; i++) {
System.out.println(array[i]);
}
for (int j = 0; j < array.length; j++){
System.out.println(array[j]);
}
// 偷懒小技巧 只能idea支持 array.fori 100.fori
// 增强for 循环
// 思路:我依次使用数组中的每一个元素，给迭代变量进行赋值
for (int element : array){
System.out.println(element);
}
}
} // 注:这个增强for循环同Python中: for i in array:print(i) 一致
// 数组中的引用
public static void main(String[] args) {
int[] array = {10, 20};
swap(array);
System.out.println(array[0]);
System.out.println(array[1]);
}
public static void swap(int[] arr) {
int temp = arr[0];
arr[0] = arr[1];
arr[1] = temp;
}
// 数组的排序
将数组中的元素按照一定的大小关系进行重新排序
选择排序:固定值与其他值依次比较大小，互换位置。
冒泡排序:相邻的两个值比较大小，互换位置。
JDK排序(java.util.Arrays.sort(数组)) // sort 方法 JDK提供默认的是升序排序(从小到大) Python中的sorted
Arrays.sort(array);
顺序查询
二分查询选择排序
// 选择排序:固定值与其他值依次比较大小，互换位置。
package com.laity.basicSyntax.day1.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day1.bArray
* @date Date : 2021年11月13日 13:44
* @Description: 选择排序
*/
public class ArraySort5 {
public static void main(String[] args) {
int[] array = {10, 5, 6, 3, 9, 2, 4};
int[] arrays = {10, 5, 6, 3, 9, 2, 4, 0, 1, 4, 7, 8};
sort1(array);
sort2(arrays);
for (int i : array) {
System.out.print(i + ", ");
}
System.out.println();
for (int i : arrays) {
System.out.print(i + ", ");
}
}
/**
* 使用选择排序，对数组array进行升序排序(从小到大)
*
* @param array
*/
public static void sort1(int[] array) {
// 选择排序
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
// 交换元素
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
public static void sort2(int[] array) {
// 完整版选择排序
// 用来控制发生了多少趟的比较
for (int i = 0; i < array.length - 1; i++) {
// 声明一个变量，用来记录剩余元素中的最小值所在的下标
int min = i;
// 让后续的每一个元素，依次和当前记录的最小值进行比较，找出新的最小值
for (int j = i + 1; j < array.length; j++) {
// 让第j位的元素和记录的最小值进行比较
if (array[min] > array[j]) {
// 更新最小值下标
min = j;
}
}
// 交换第i位和第min位的元素
if (i != min) {
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}
}冒泡排序
// 冒泡排序:相邻的两个值比较大小，互换位置。
package com.laity.basicSyntax.day1.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day1.bArray
* @date Date : 2021年11月13日 16:46
* @Description: 冒泡排序
*/
public class ArraySort6 {
public static void main(String[] args) {
// 实例化一个数组
int[] array = {1, 3, 7, 2, 9, 4, 8, 0, 6, 5};
// 对数组进行排序
sort1(array);
// 循环打印
for (int i : array) {
System.out.print(i + ",");
}
}
/**
* 使用冒泡排序对数组进行升序排序
* 冒泡排序的核心思想:每趟比较从第0位开始依次比较两个相邻的元素，当满足交换条件的时候，交换
*
* @param array
*/
public static void sort1(int[] array) {
// 循环比较发生了多少趟
for (int i = 0; i < array.length - 1; i++) {
// 控制每一趟的比较发生了多少次
// j < array.length - 1 - i
for (int j = 0; j < array.length - 1 - i; j++) {
// 依次比较两个相邻的元素
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}顺序查询
package com.laity.basicSyntax.day1.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day1.bArray
* @date Date : 2021年11月13日 16:59
* @Description: 顺序查询
*/
public class FindElement7 {
public static void main(String[] args) {
int[] array = {1, 3, 5, 6, 9, 7, 2, 0, 10};
int index = indexOf(array, 50);
System.out.println(index); // 返回索引
}
/**
* 使用顺序查询，查询数组中指定的元素出现的下标
*
* @param array 需要去查询的数组
* @param element 需要查询的元素
* @return 元素出现的下表；如果元素不存在，则返回-1；
*/
public static int indexOf(int[] array, int element) {
// 遍历数组中的每一个元素
for (int i = 0; i < array.length; i++) {
// 将每一个元素依次和要查询的元素进行比较
if (array[i] == element) {
// 如果比较通过，则这个下标就是要查询的元素下标
return i;
}
}
// 如果循环走完，还没有结果返回，那就说明这个元素不存在
// 不存在的元素，我们统一返回-1
return -1;
}二分查询
// 即利用数组中间的位置，将数组分为前后两个子表。如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
// 二分查询，要求数组必须是排序的，否则无法使用二分查询。(就是已经排好序的:升序或者降序的)
package com.laity.basicSyntax.day2.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day2.bArray
* @date Date : 2021年11月14日 11:34
* @Description: 二分查询
*/
public class BinarySearch {
public static void main(String[] args) {
int[] array = {1, 4, 6, 7, 8, 10, 12, 13};
int index = binarySearch(array, 10);
System.out.println(index);
}
/**
* 从一个数组中，使用二分查询法，查询元素的下标
*
* @param array 需要查询的数组
* @param element 需要查询的元素
* @return 下标
*/
public static int binarySearch(int[] array, int element) {
// 定义两个变量，分别记录范围的上线和下限
int min = 0, max = array.length - 1;
while (max >= min) {
// 找到中间下标
int mid = (max + min) / 2;
// 判断中间的元素和要查询的元素的大小关系
if (array[mid] == element) {
return mid;
} else if (array[mid] > element) { // 查左边
// 修改范围的上线
max = mid - 1;
} else {
// 修改范围的下限
min = mid + 1;
}
}
// 如果循环走完了，依然没有结果返回，说明要查询的这个数据在数组中不存在
return -1;
}
}可变长参数
// 概念:可以接收多个类型相同的参数，个数不限，使用方法与数组相同。
// 在调用方法的时候，实参的数量可以写任意多个。 本质还是一个数组
// 语法：数据类型... 形参名(必须放到形参列表的最后位，且只能有一个)
package com.laity.basicSyntax.day2.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day2.bArray
* @date Date : 2021年11月14日 12:13
* @Description: 可变长度的参数列表
*/
public class MutipleParameter {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int Max = getMax(array);
System.out.println("最大值:" + Max);
int Min = getMin(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 可以这样写
System.out.println("最小值:" + Min);
}
public static int getMax(int[] array) {
int max = array[0];
for (int element : array) {
if (element > max) {
max = element;
}
}
return max;
}
public static int getMin(int... arrays) { // int... arrays 不等长参数的写法
int min = arrays[0];
for (int element : arrays) {
if (element < min) {
min = element;
}
}
return min;
}
}二维数组
// int[][] array3 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
package com.laity.basicSyntax.day2.bArray;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day2.bArray
* @date Date : 2021年11月14日 14:28
* @Description: 二维数组
*/
public class Array2 {
public static void main(String[] args) {
// 二维数组的元素访问
// 1.实例化一个二维数组
int[][] array = new int[5][3];
// 2.获取数组中的小数组
int[] arr = array[1];
// 3.修改数组中的小数组
array[1] = new int[]{2, 3, 4, 5, 6, 7, 8};
System.out.println(array);
// 4.获取小数组中的数据
int ele = array[1][4];
System.out.println(ele);
// 5.修改小数组中的数据
array[2][2] = 3;
System.out.println(array);
}
public static void initArray() {
// 1.二维数组的定义和实例化
// int[][] array; // 声明一个二维数组，这个数组中，存储的每一个元素，都是一个小的一维数组
// 1.1给定一个二维数组的长度，进行二维数组的实例化
// 此时这个二维数组中存储的元素是 null
int[][] array1 = new int[5][];
for (int[] ints : array1) {
System.out.println(ints);
}
// 1.2 给定一个二维数组的长度，同时给定一维数组的长度，进行实例化
// 此时，这个二维数组中存储的一维数组，已经完成了实例化了
// 这个3仅仅是初始的长度，后面可以改
int[][] array2 = new int[5][3];
System.out.println(array2);
// 1.3 通过指定的值，进行数组的实例化
int[][] array3 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
System.out.println(array3);
// 1.4 最简化
int[][] array4 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
System.out.println(array4);
}
}Arrays工具类
// 里面包含了若干个对数组进行操作的工具方法
// 工具方法:方便对数组进行操作的方法
package com.laity.basicSyntax.day2.bArray;
import java.util.Arrays; // 导包
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day2.bArray
* @date Date : 2021年11月14日 15:00
* @Description: Arrays工具类
* 里面包含了若干个对数组进行操作的工具方法
* 工具方法:方便对数组进行操作的方法
*/
public class ArrayTools {
public static void main(String[] args) {
// System.arraycopy();
// 数组拷贝: 将一个数组中的指定位开始的元素拷贝到目标数组中的指定位，拷贝length长度的元素
// 注意事项:不要发生下标越界的情况
// arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
// Object src: 原数组
// int srcPos: 原数组指定位开始拷贝位置
// Object dst: 目标数组
// int dstPos: 目标数组指定位开始拷贝位置
// int length: 拷贝的元素的数量 就是拷贝的长度
int[] src = {1, 3, 5, 7, 8, 9, 10};
int[] dst = {20, 30, 40, 50, 60, 70};
System.arraycopy(src, 1, dst, 1, 3);
System.out.println(Arrays.toString(dst));
}
/**
* 基本工具的使用
*/
public static void ArrayUsage() {
// 1.准备一个数组
int[] array = {1, 3, 5, 7, 8, 9, 10, 17};
int[] arr = {1, 3, 4, 7, 8, 9, 10, 17};
// 2.工具方法:
// 如果newLength超出了原数组的长度，依然可以拷贝，只是在最后的结果添加了 0
int[] ret = Arrays.copyOf(array, 5); // 从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组
// 2.1 将数组中的元素拼接成字符串返回
String ret1 = Arrays.toString(ret); // 拼接成字符串返回
System.out.println(ret1);
// 2.2 从原数组中拷贝指定的范围 [from, to) 的元素，到一个新的数组中，并且返回这个新的数组
// to 是可以越界的，后面会用0指定的位数，form是不可以越界的，否则会报异常的
int[] ret3 = Arrays.copyOfRange(array, 2, 7);
System.out.println(Arrays.toString(ret3));
// 2.3 判断两个数组是否相同
boolean equals = Arrays.equals(array, arr); // 这个有快捷键 .var
System.out.println(equals);
// 2.4 使用指定的数据填充数组
Arrays.fill(array, 8); // 将数组的所有元素都填充为8
System.out.println(Arrays.toString(array));
// 2.5 对数组中的元素进行排序(升序排序)
Arrays.sort(array);
System.out.println(Arrays.toString(array)); // JDK排序
// 2.6 使用二分查询法，查询数组中指定的元素出现的下标
int index = Arrays.binarySearch(array, 7);
System.out.println(index);
}
}数组的拓展功能
package com.laity.basicSyntax.day2.bArray;
import java.util.Arrays;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day2.bArray
* @date Date : 2021年11月14日 23:45
* @Description: 数组中的拓展到功能
*/
public class ArrayExtension {
public static void main(String[] args) {
// 数组的扩容: 实例化一个新的指定长度的数组，将原来数组中的元素依次拷贝到这个新的数组中即可
int[] original = {1, 4, 7, 8, 9};
// 需求:在现有元素的后面添加一个 0
// 1. 对original数组进行扩容，使其容量加1
int[] newArray = new int[original.length + 1];
// 2. 依次将original中的每一个元素拷贝到新的数组中
for (int i = 0; i < original.length; i++) {
newArray[i] = original[i];
}
// 3.将 0 放到newArray的最后一位
newArray[newArray.length - 1] = 0;
// 4.重定向original的地址指向
original = newArray;
// 5.遍历数组，输出数组中的所有的元素
System.out.println(Arrays.toString(original)); // [1, 4, 7, 8, 9, 0]
int[] array = add(original, 10);
System.out.println(Arrays.toString(array));
// array = remove(original, 3);
array = newRemove(original, 3);
System.out.println(Arrays.toString(array));
}
/**
* 关于数组扩容的基本思路
*/
public static void growup() {
// 关于数组扩容的基本思路
}
/**
* 希望将一个元素拼接到一个现有数组的最后
*
* @param array 现有的数组
* @param element 需要拼接的元素
* @return 添加元素之后的数组
*/
public static int[] add(int[] array, int element) {
// 1. 对original数组进行扩容，使其容量加1
// 2. 依次将original中的每一个元素拷贝到新的数组中
array = Arrays.copyOf(array, array.length + 1);
// 3.将 element 放到newArray的最后一位
array[array.length - 1] = element;
// 4.返回拼接好的数组
return array;
}
/**
* 需要从array数组中移除指定下标位的元素
*
* @param array 被操作的数组
* @param element 被删除元素的下标
* @return 返回删除元素之后的数组
*/
public static int[] remove(int[] array, int element) {
if (element < 0 || element >= array.length) {
return array;
}
// 1.实例化一个新的数组，新数组的长度是原数组的长度-1
int[] newArray = new int[array.length - 1];
// 2.拷贝前后两部分的数据
System.arraycopy(array, 0, newArray, 0, element);
System.arraycopy(array, element + 1, newArray, element, array.length - 1 - element);
// 3.返回结果
return newArray;
}
public static int[] newRemove(int[] array, int element) {
if (element < 0 || element >= array.length) {
return array;
}
// 用element位之后的元素依次向前覆盖
System.arraycopy(array, element + 1, array, element, array.length - 1 - element);
// 返回结果
return Arrays.copyOf(array, array.length - 1);
}
}数组的堆和栈
int[] array = new int[5];
快捷键整理
// 1. sout // 2. main // 3. 循环遍历数组的时候: array.fori array.for // 4. Arrays中 Arrays.equals(array, arr).var // 5. Alt+Enter // 6. 重写父类的方法 父类的方法名回车即可