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];

JavaEE入门级别最全教程1--初学者必看_第1张图片

 

快捷键整理

// 1. sout
// 2. main
// 3. 循环遍历数组的时候: array.fori   array.for
// 4. Arrays中 Arrays.equals(array, arr).var
// 5. Alt+Enter
// 6. 重写父类的方法 父类的方法名回车即可

你可能感兴趣的:(Java基础知识讲解与总结,javaee,java,初学者)