导读

相信很多初入编程的小伙伴对于语言有种选择恐惧症，对于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 + 11010 1101  源码1101 0010 + 1 = 1101 0011  补码 向右移动两位 溢出的就不要了 1111 0100 11  --> 11舍移动后的补码  : 1111 0100再反转位源码  : 1000 1011 + 1 = 1000 1100最终结果为      -12在右移运算的时候，每像右移动一位，相当于除了一个2，但是这里遵循向下取整  11.25 = 12 面试题:
如何高效率的计算 2*82*8 是 2+了八次8*2 是 8+82<<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
引用数据类型:nullpublic class Array1 {public static void main(String[] args) {// 前言:使用[]表示一个数组，中括号前写数组中可以存储的数据类型// 1.声明一个数组// 2.数组的实例化:在为数组分配内存空间，并且分配数组中初始的值// new： 为数组开辟空间，需要使用关键字new// 实例化的同时，指定这个数组的长度// 数组中的数据默认值为:int[] array = new int[5];  // int[5] 表示存储的容量为5// 实例化数组的同时，指定这个数组中存储的数据// 此时这个数组中，默认存储了5个数据，也就是说数组的长度为5int[] 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中的sortedArrays.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 - ifor (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;}}// 如果循环走完，还没有结果返回，那就说明这个元素不存在// 不存在的元素，我们统一返回-1return -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给定一个二维数组的长度，进行二维数组的实例化// 此时这个二维数组中存储的元素是 nullint[][] 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超出了原数组的长度，依然可以拷贝，只是在最后的结果添加了 0int[] 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);  // 这个有快捷键  .varSystem.out.println(equals);// 2.4 使用指定的数据填充数组Arrays.fill(array, 8);  // 将数组的所有元素都填充为8System.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数组进行扩容，使其容量加1int[] 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.实例化一个新的数组，新数组的长度是原数组的长度-1int[] 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. 重写父类的方法 父类的方法名回车即可

JavaEE入门级别最全教程1--初学者必看相关推荐

JavaEE入门级别最全教程4--初学者必看
健康万岁,商业无罪,大家好我是Laity也是你们的J哥. 一.JavaWeb介绍使用Java技术来解决相关web互联网领域的技术栈(其实就是开发网站) Java 的 api齐全,历史悠久.(后台开发 ...
JavaEE入门级别最全教程2--初学者必看
接JavaEE入门级别最全教程1--初学者必看 JavaEE入门(3w字) 如果你比较穷,一定要学计算机:计算机一定不是你翻身的行业,但一定会让你的生活变得更好. 我无力改变,只有奋斗,与其被卷掉,倒 ...
lua菜鸟教程_初学者必看：Lua入门学习教程
Lua入门学习教程是本文要介绍的内容,主要是来对Lua入门的一个学习,Lua是一个被设计成用于扩展C/C++编程的轻量级脚本语言.不幸的是,网上很少有关于这个语言的在线教程.我主要通过阅读其源代码来了 ...
C语言入门，C语言学习方法，初学者必看
学C语言的朋友应该首先了解C语言关键的核心概念(结构化.三个执行流程.优先级.指针.文件.共用体.函数.作用域.重载等 ),只有弄明白了这些才能在今后的学习中游刃有余的把握C语言的精髓.这几个概念就像 ...
Qt Designer入门教程初学者必看
在Linux下,一个非常流行的RAD工具就是Qt Designer.它是嵌入式公司 Trolltech的Qt软件包的一个组成部分. Qt Designer入门教程初学者必看是本文要介绍的内容,不说这 ...
电脑音频服务未运行怎么解决_电脑故障维修技巧教程：新手必看的修电脑技巧！...
日常生活工作中,我们的电脑总会出现各种各样的问题,如果掌握了一定的通用修电脑技巧,除了可以解决问题,说不定还能得到帮女神修电脑的机会,俗话说的好,电脑修的好,对象少不了!电脑故障判断一般本着先&quo ...
it招聘上说熟悉linux系统,运维入门：细说Linux，做IT必看
原标题:运维入门:细说Linux,做IT必看 Linux进程和系统.任务管理一.基本概念程序:一组指令的集合进程:程序的具体实现,执行程序的具体过程子进程调用:fork-and-exec流程: ...
计算机键盘分区,电脑初学者必看键盘五个分区功能知识.doc
文档介绍: 电脑初学者必看键盘五个分区功能知识,电脑初学者必看键盘基本分区,初学者熟悉键盘,初学者熟悉键盘图片,美发初学者分区要多久,初学者熟悉键盘视频,电脑键盘功能介绍,钢琴键盘示意图简谱,键盘26 ...
至PJ初学者！（初学者必看）
至PJ初学者!(初学者必看) dOSKEY lEE 首先,请您先明确几个问题: 1.您为什么学习PJ? 2.您想通过什么途径学习PJ? 3. ...

JavaEE入门级别最全教程1--初学者必看

导读

大数据的概述

Java基础

Java的数据类型分类

标识符

变量/常量

类型转换

常用运算符

流程控制

循环案例

方法

数组

选择排序

冒泡排序

顺序查询

二分查询

可变长参数

二维数组

Arrays工具类

数组的拓展功能

数组的堆和栈

快捷键整理

JavaEE入门级别最全教程1--初学者必看相关推荐

最新文章

热门文章