devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：2023面试高手 | 2024-06-02 19:51:21

赞

踩

javaee教程

导读

相信很多初入编程的小伙伴对于语言有种选择恐惧症，对于Java也不知怎么去学，这期文章J哥会给大家整理最适合小白学习的JavaEE教程。

大数据的概述

  1. # 大数据与云计算的学习
  2. 概念:海量数据，具有高增长率、数据类型多样性、一定时间内无法使用常规软件进行捕捉、管理和处理的数据集合。
  3. 特征:4V特征(是大家普遍认可的)
  4.     大量
  5.     多样
  6.     高速
  7.     价值
  8. # 大数据能做什么？
  9. 在海量的各种各样类型的价值密度低的数据中，我们要进行的是: 数据采集、数据存储、数据清洗、数据分析、数据可视化。这个过程就是大数据要做的主要事情。
  10. # 使用语言
  11. JAVA8稳定(最新14)
  12. Write Once Run Anywhere  (一次编译处处运行)
  13.     JDK 开发环境
  14.     JRE 运行环境
  15.     JVM 虚拟机

Java基础

Java的数据类型分类

  1. // 基本数据类型
  2. 整型
  3.     - 字节型:byte
  4.     - 短整型:short
  5.     - 整型:int
  6.     - 长整型:long
  7. 浮点型
  8.     - 单精度浮点型:float
  9.     - 双精度浮点型:double
  10. 字符型:char
  11. 布尔型:boolean
  12. // 引用数据类型

标识符

  1. // 标识符，是由若干个字符组成的有序数列。在标识符中应该遵守的规则:
  2. 1.由字母数字下划线和$组成
  3. 2.不能以数字开头
  4. 3.不能与系统关键字或者保留字重名
  5. // 命名规范(驼峰命名法)
  6. 1.望文之意
  7. 2.驼峰命名法(大驼峰命名法、小驼峰命名法)
  8.     - 首字母大写
  9.     - 除首单词除外
  10.     - 没有特殊说明默认用小驼峰命名法

变量/常量

# 计算机内存中的一块存储空间，是存储数据的基本单元 值可以改变称之为变量 (年龄、体重) 值不可以改变称之为常量(一个人的出生日期) IDEA中操作了

类型转换

  1. // 强制类型转换
  2. // 自动类型转换
  3. // 特殊说明:
  4. 	1.byte short char 类型的数据在进行运算的时候会自动的转换为int类型
  5.     2.浮点型转整型 会舍弃小数点后面的所有内容 只保留整数部分

常用运算符

  1. // 算数  + - * / %   ++  --
  2. 	++自增运算符  
  3.         位于变量后表示先取值再进行加1的操作
  4.         位于变量前表示先进行加1后取值的操作
  5.     --自减运算符
  6.         与++一致
  7.     ++ 与 —— 的优先级最高
  8. // 赋值运算符   =
  9.        可以和其他运算符组合成 组合运算符
  10.        组合运算符 隐性的包含了类型转换
  11. // 关系运算符  > >= = < <=  == !=  
  12.     //  1.关系运算符的结果一定是布尔类型的
  13.     //  2.等值比较需要注意，使用的是双等号
  14. // 逻辑运算符  &  |  !  ^  &&  ||   对两个布尔值进行的运算
  15.    java   python  go   javascript  c
  16.      &     and    &&       &&      &&          与  :逻辑与，两真即为真，任意一个为假，结果即为假  false
  17.      |     or     ||       ||      ||          或  :逻辑或，两假即为假，任意一个为真，结果即为真  true
  18.      !	   not     ！       ！       ！         非  :逻辑非，非真即假，非假即真。
  19.      ^                                         异或 :逻辑异或，相同为假，不同为真。
  20.      &&										   短路与，如果前面的结果可以决定整体的运算结果，后面的表达式不参与运算
  21.      ||										   短路或，如果前面的结果可以决定整体的运算结果，后面的表达式不参与运算
  22.    javascript中逻辑运算符取决于右侧，右边为什么返回的值就为什么
  23. // 位运算符  
  24. 	只能位于两个整型的运算
  25. 	&	位与运算，对补码的每一位进行与运算
  26.     |   位或运算，对补码的每一位进行或运算
  27.     ^   位异或运算，对补码的每一位进行异或运算
  28.     ~   按位取反运算   包括符号位
  29.     <<  按左移运算
  30.     >>  按右移运算  最高位补符号位  
  31.     >>> 无符号位右移运算   左侧补0    就是最高位补的不是符号位 而是0
  32. 符号  64 32 16     8421
  33. 0   (0  0   0)   (0000)  --> 源码直接这样写
  34.     补码:举例:
  35. -45 = 32 + 8 + 4 + 1
  36.     1010 1101  源码
  37.     1101 0010 + 1 = 1101 0011  补码 向右移动两位 溢出的就不要了 1111 0100 11  --> 11舍
  38.     移动后的补码  : 1111 0100
  39. 	再反转位源码  : 1000 1011 + 1 = 1000 1100
  40.     最终结果为      -12
  41.     在右移运算的时候，每像右移动一位，相当于除了一个2，但是这里遵循向下取整  11.25 = 12 
  42.     面试题:
  43. 如何高效率的计算 2*8
  44.     2*8 是 2+了八次
  45.     8*2 是 8+8
  46.     2<<3  这个效率最高
  47.     
  48. // 三目运算符
  49.     表达式 :布尔结果表达式/布尔变量?值1 : 值2
  50.     如果问好前面的布尔值是true，整体的结果为值1。否则整体的结果为值2。
  51. // 运算符的优先级
  52.         整体看:一元运算符(只能操作一个数据:+ - ++ -- ! ~)>二元运算符(可以操作两个数据:+ - * /)>三元运算符(三目运算符  ? :)
  53.         赋值运算符的优先级最低
  54.         算数运算符中: 乘除模 > 加减
  55.         逻辑运算符中: 与 > 或、异或
  56.         小括号的优先级最高

流程控制

  1. // 流程控制分类
  2. 	顺序结构/分支结构/循环结构    --java
  3.     顺序结构/分支结构/循环结构 	  --C
  4.     	顺序结构: 代码从上往下，逐行依次执行。是程序执行的默认结构
  5.         分支结构: 程序在某一个节点遇到了多种可能向下执行的可能性，根据条件，选择一个分支继续执行
  6.         循环结构: 某一段代码需要被重复执行多次。
  7. // 分支流程控制-if/switch
  8.             // 第一种 if else
  9. if (condition) {  // condition 判断条件(布尔 boolean)
  10.     // 代码段1
  11. }
  12. else{
  13.     // 代码段2
  14. }
  15. 		// 第二种  if - else if
  16. if(){
  17.     
  18. }else if(){
  19.     
  20. }...
  21. else{
  22.     
  23. }
  24. 		 // switch
  25. switch(变量){
  26.     case 值1{
  27.         // 分支语句1
  28.     }
  29.     case 值2{
  30.         // 分支语句2
  31.     }...
  32.     default:
  33. }
  34. 		// 实例
  35. int season = 1;
  36. switch (season) {
  37.     case 1:
  38.         System.out.println("春天");
  39.         break;
  40.     case 2:
  41.         System.out.println("夏天");
  42.         break;
  43.     case 3:
  44.         System.out.println("秋天");
  45.         break;
  46.     case 4:
  47.         System.out.println("冬天");
  48.         break;
  49.     default:
  50.         System.out.println("错误的季节");
  51. }
  52. switch具有穿透性:指的是，当switch的变量和某一个case值匹配上之后，将会跳过后续的case或者default的匹配，直接向后穿透。
  53. 为了杜绝穿透，可以使用关键字break;
  54. // 循环流程控制-for/while
  55. for(循环的起点、循环的条件、循环的步长){
  56.     // 这里的代码，将在循环条件成立的时候重复执行
  57.     // 这里 又叫 循环体
  58. }
  59. 循环起点: 只会执行一次 通常用于定义一个用来控制循环的变量
  60. 循环条件: 布尔结果的表达式，当成立的时候，循环体执行
  61. 循环步长: 记录每次循环发生的变化，通常用于改变控制循环的变量的值
  62. // while
  63. while (循环条件){
  64.     // 循环体
  65. }
  66.  
  67. // do-while
  68. do {
  69.     // 循环体
  70. } while (循环条件);
  71. 如果从一开始的条件都是不成立的，那么do-while比while循环多执行一次逻辑
  72.     
  73. // 两个关键字
  74. 	break     无论循环条件是否成立，立即结束循环
  75.     continue  立即停止本次循环，立即进入下次循环
  76.  
  77. 如果循环的次数是可预期的 推荐使用for循环
  78. 如果循环的次数是不可预期的，但是有明确的结束条件，推荐使用while循环
  79.  
  80. // 循环标签
  81. OUTER: // 通过内部循环结束外部循环
  82. for (int i = 1; i <= 5; i++) {
  83.     for (int j = 1; j <= 5; j++) {
  84.         if (j == 3) {
  85.             break OUTER;
  86.         }
  87.         System.out.println("i = "+ i + ", j = " + j);
  88.     }
  89. }

循环案例

  1. // 输出0-100所有奇数和
  2. int sum = 0;
  3. for (int number = 1; number <= 100; number++) {
  4.     if (number % 2 != 0) {
  5.         // System.out.println(number);
  6.         sum += number;
  7.     }
  8. }
  9. System.out.println(sum);
  10. // 打印九九乘法表
  11. int line = 1;
  12. for (; line <= 9; line++) {
  13.     for (int column = 1; column <= line; column++) {
  14.         System.out.print(column + "x" + line + "=" +column*line + "   ");  // java的print没有换行  println自带一个换行符
  15.     } // python 中print有换行 需要 print(公式,end="")
  16.     System.out.println();
  17. } 
  18. // 百钱白鸡
  19. // 已知 每只母鸡5元钱，每只公鸡三元钱，三只小鸡一元钱
  20. // 有100元去买鸡，要求正好花完100元，且购买100只鸡
  21. // 输出所有的购买方案
  22. for (int m = 0; m <= 100 / 5; m++) {
  23.     for (int g = 0; g < 100 / 3; g++) {
  24.         for (int x = 0; x <= 100; x += 3) {
  25.             // 小鸡的数量是三的倍数
  26.             if (m * 5 + g * 3 + x / 3 == 100 && m + g + x == 100) {
  27.                 System.out.println("可以买:母鸡" + m + "公鸡" + g + "小鸡" + x);
  28.             }
  29.         }
  30.     }
  31. }

方法

  1. // 方法的概念
  2. 我们将需要被多次执行的逻辑包装起来，在需要的时候直接调用即可。
  3. 方法就是为了事项这个需求而存在的(使其可以重复调用、降低代码的冗余、提高代码的复用性与维护性)
  4. // 方法的定义与调用
  5. [访问权限修饰符][其他的修饰符]返回值类型 方法名称([参数列表]){
  6.     方法体
  7. }
  8. public class FirstMethod {
  9.     public static void main(String[] args) {
  10.         // 访问权限修饰符:访问权限修饰符
  11.         // 其他修饰符: static
  12.         // 返回值类型: void
  13.         // 方法的名字: 小驼峰命名
  14.         // 小括号里面写参数列表
  15.         print();  // 调用方法
  16.     }
  17.  
  18.     public static void print() {  // 如果需要这个方法中的逻辑被执行，则需要进行方法的调用
  19.         // 方法体
  20.         System.out.println("This is my first method");
  21.     }
  22. }
  23. ·方法是定义在类的内部的，与main函数并列(方法中不允许套用方法)
  24. 访问权限修饰符
  25. // 方法的参数
  26. 调用方法时，传入的数据被称为  参数(定义在小括号中)
  27.     形参: 定义方法时定义的参数
  28.     实参: 需要传的值
  29.     传参: 实参给形参赋值-->传参
  30. // 方法的返回值
  31. 函数调用时，一些情况下无需返回结果;另一些情况下则必须有返回值
  32.     return 关键字:表示方法执行的结果；方法的结束。
  33.     
  34. public class ReturnType {
  35.     public static void main(String[] args) {
  36.         System.out.println("和为:" + add(1, 2));
  37.     }
  38.  
  39.     public static int add(int num1, int num2) {  // int 返回值类型
  40.         return num1 + num2;
  41.     }
  42. }
  43. // 方法的重载
  44. 在一个类的方法中，如果多个方法满足如下条件，则他们之间的关系就是重载
  45.     ·方法名相同
  46.     ·参数不同
  47.     	~参数不同，体现在参数的数量不同或者参数的类型不同 (方法的入口不同)
  48. 注意: 方法的重载与返回值没有关系！
  49. public class Overload {
  50.     public static void main(String[] args) {
  51.         add();
  52.         add(2);
  53.         add(3, 4);
  54.         add("aa");
  55.     }
  56.  
  57.     public static void add() {
  58.         System.out.println("无参数");
  59.     }
  60.  
  61.     public static void add(int num1) {
  62.         System.out.println("add(int)");
  63.     }
  64.  
  65.     public static void add(int num1, int num2) {
  66.         System.out.println("add(int int)");
  67.     }
  68.  
  69.     public static void add(String s) {
  70.         System.out.println("add(String)");
  71.     }
  72. }
  73.  
  74. // 方法的递归
  75. 递归，是一种程序设计的思想。在解决问题的时候，可以将问题拆分成若干个小问题。通过解决这些小问题，逐渐解决这个大问题。
  76.  
  77. package com.laity.basicSyntax.method;
  78.  
  79. /**
  80.  * @author : Laity
  81.  * @Project: JavaLaity
  82.  * @Package com.laity.basicSyntax.method
  83.  * @date Date : 2021年11月12日 23:36
  84.  * @Description: 方法的递归
  85.  */
  86. public class Method2 {
  87.     public static void main(String[] args) {
  88.         // multiply(9);
  89.         System.out.println(multiply(10));
  90.         System.out.println(sum(100));
  91.     }
  92.  
  93.     /**
  94.      * /** 按ctrl + 回车
  95.      * 计算一个数字的阶乘
  96.      *
  97.      * @param num 需要计算阶乘的数字
  98.      * @return 计算的结果
  99.      */
  100.     public static int multiply(int num) {
  101.         // 设置出口条件
  102.         if (num == 1) {
  103.             return 1;
  104.         }
  105.         // 递进与回归(自己调用自己)
  106.         return num * multiply(num - 1);
  107.     }
  108.  
  109.     public static int sum(int n) {
  110.         if (n == 1) {
  111.             return 1;
  112.         }
  113.         return n + sum(n - 1);
  114.     }
  115. }

数组

  1. // 概念：一组连续的存储空间，存储多个相同数据类型的值(是一个数据容器)
  2. 特点:类型相同、长度固定。
  3. // 数组的声明  (注释:以后只要看到 关键字new 都是在堆上开辟空间)
  4. int [] array = new int[5];  // int[5] 表示array这个数组存储的容量为5
  5. 数组中的数据默认值为:
  6. 整型:0
  7. 浮点型:0.0
  8. 字符型:'\u0000'
  9. 布尔型:false
  10. 引用数据类型:null
  11.     
  12. public class Array1 {
  13.     public static void main(String[] args) {
  14.         // 前言:使用[]表示一个数组，中括号前写数组中可以存储的数据类型
  15.         // 1.声明一个数组
  16.         // 2.数组的实例化:在为数组分配内存空间，并且分配数组中初始的值
  17.         // new： 为数组开辟空间，需要使用关键字new
  18.         // 实例化的同时，指定这个数组的长度
  19.         // 数组中的数据默认值为:
  20.         int[] array = new int[5];  // int[5] 表示存储的容量为5
  21.         // 实例化数组的同时，指定这个数组中存储的数据
  22.         // 此时这个数组中，默认存储了5个数据，也就是说数组的长度为5
  23.         int[] array2 = new int[]{1, 2, 3, 4, 5};
  24.         // 省略new int[]
  25.         int[] array3 = {1, 2, 3, 4, 5};
  26.     }
  27. }
  28. // 访问数组中的元素
  29. public class Array2 {
  30.     public static void main(String[] args) {
  31.         // 1.实例化一个数组
  32.         int[] array = {1, 2, 3, 4, 5};
  33.         // 2.用里面的元素时，两种操作:读和写
  34.         int a = array[2];
  35.         System.out.println(a);
  36.         // 3..修改数组中的元素
  37.         array[3] = 100;
  38.         System.out.println(array[3]);
  39.     }
  40. }
  41. // 数组的遍历
  42. 就是按照数组中元素存储的顺序，依次拿到数组中的每一个元素。
  43.     
  44. package com.laity.basicSyntax.day1.bArray;
  45.  
  46. /**
  47.  * @author : Laity
  48.  * @Project: JavaLaity
  49.  * @Package com.laity.basicSyntax.day1.bArray
  50.  * @date Date : 2021年11月13日 9:54
  51.  * @Description: 数组的遍历
  52.  */
  53. public class Array3 {
  54.     public static void main(String[] args) {
  55.         int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  56.         for (int i = 0; i <= 9; i++) {
  57.             System.out.println(array[i]);
  58.         }
  59.         for (int j = 0; j < array.length; j++){
  60.             System.out.println(array[j]);
  61.         }
  62.         // 偷懒小技巧 只能idea支持 array.fori  100.fori
  63.  
  64.         // 增强for 循环
  65.         // 思路:我依次使用数组中的每一个元素，给迭代变量进行赋值
  66.         for (int element : array){
  67.             System.out.println(element);
  68.         }
  69.     }
  70. }  // 注:这个增强for循环同Python中: for i in array:print(i) 一致
  71.  
  72. // 数组中的引用
  73. public static void main(String[] args) {
  74.     int[] array = {10, 20};
  75.     swap(array);
  76.     System.out.println(array[0]);
  77.     System.out.println(array[1]);
  78. }
  79.  
  80. public static void swap(int[] arr) {
  81.     int temp = arr[0];
  82.     arr[0] = arr[1];
  83.     arr[1] = temp;
  84. }
  85. // 数组的排序
  86. 将数组中的元素按照一定的大小关系进行重新排序
  87.     选择排序:固定值与其他值依次比较大小，互换位置。
  88.     冒泡排序:相邻的两个值比较大小，互换位置。
  89.     JDK排序(java.util.Arrays.sort(数组)) // sort 方法  JDK提供默认的是升序排序(从小到大)  Python中的sorted
  90.     Arrays.sort(array);
  91. 	顺序查询
  92.     二分查询

选择排序

  1. // 选择排序:固定值与其他值依次比较大小，互换位置。
  2. package com.laity.basicSyntax.day1.bArray;
  3.  
  4. /**
  5.  * @author : Laity
  6.  * @Project: JavaLaity
  7.  * @Package com.laity.basicSyntax.day1.bArray
  8.  * @date Date : 2021年11月13日 13:44
  9.  * @Description: 选择排序
  10.  */
  11. public class ArraySort5 {
  12.     public static void main(String[] args) {
  13.         int[] array = {10, 5, 6, 3, 9, 2, 4};
  14.         int[] arrays = {10, 5, 6, 3, 9, 2, 4, 0, 1, 4, 7, 8};
  15.         sort1(array);
  16.         sort2(arrays);
  17.         for (int i : array) {
  18.             System.out.print(i + ", ");
  19.         }
  20.         System.out.println();
  21.         for (int i : arrays) {
  22.             System.out.print(i + ", ");
  23.         }
  24.     }
  25.  
  26.     /**
  27.      * 使用选择排序，对数组array进行升序排序(从小到大)
  28.      *
  29.      * @param array
  30.      */
  31.     public static void sort1(int[] array) {
  32.         // 选择排序
  33.         for (int i = 0; i < array.length - 1; i++) {
  34.             for (int j = i + 1; j < array.length; j++) {
  35.                 if (array[i] > array[j]) {
  36.                     // 交换元素
  37.                     int temp = array[i];
  38.                     array[i] = array[j];
  39.                     array[j] = temp;
  40.                 }
  41.             }
  42.         }
  43.     }
  44.  
  45.     public static void sort2(int[] array) {
  46.         // 完整版选择排序
  47.         // 用来控制发生了多少趟的比较
  48.         for (int i = 0; i < array.length - 1; i++) {
  49.             // 声明一个变量，用来记录剩余元素中的最小值所在的下标
  50.             int min = i;
  51.             // 让后续的每一个元素，依次和当前记录的最小值进行比较，找出新的最小值
  52.             for (int j = i + 1; j < array.length; j++) {
  53.                 // 让第j位的元素和记录的最小值进行比较
  54.                 if (array[min] > array[j]) {
  55.                     // 更新最小值下标
  56.                     min = j;
  57.                 }
  58.             }
  59.             // 交换第i位和第min位的元素
  60.             if (i != min) {
  61.                 int temp = array[i];
  62.                 array[i] = array[min];
  63.                 array[min] = temp;
  64.             }
  65.  
  66.         }
  67.     }
  68. }

冒泡排序

  1. // 冒泡排序:相邻的两个值比较大小，互换位置。
  2. package com.laity.basicSyntax.day1.bArray;
  3.  
  4. /**
  5.  * @author : Laity
  6.  * @Project: JavaLaity
  7.  * @Package com.laity.basicSyntax.day1.bArray
  8.  * @date Date : 2021年11月13日 16:46
  9.  * @Description: 冒泡排序
  10.  */
  11. public class ArraySort6 {
  12.     public static void main(String[] args) {
  13.         // 实例化一个数组
  14.         int[] array = {1, 3, 7, 2, 9, 4, 8, 0, 6, 5};
  15.         // 对数组进行排序
  16.         sort1(array);
  17.         // 循环打印
  18.         for (int i : array) {
  19.             System.out.print(i + ",");
  20.         }
  21.     }
  22.  
  23.     /**
  24.      * 使用冒泡排序对数组进行升序排序
  25.      * 冒泡排序的核心思想:每趟比较从第0位开始依次比较两个相邻的元素，当满足交换条件的时候，交换
  26.      *
  27.      * @param array
  28.      */
  29.     public static void sort1(int[] array) {
  30.         // 循环比较发生了多少趟
  31.         for (int i = 0; i < array.length - 1; i++) {
  32.             // 控制每一趟的比较发生了多少次
  33.             // j < array.length - 1 - i
  34.             for (int j = 0; j < array.length - 1 - i; j++) {
  35.                 // 依次比较两个相邻的元素
  36.                 if (array[j] > array[j + 1]) {
  37.                     int temp = array[j];
  38.                     array[j] = array[j + 1];
  39.                     array[j + 1] = temp;
  40.                 }
  41.             }
  42.         }
  43.     }
  44. }

顺序查询

  1. package com.laity.basicSyntax.day1.bArray;
  2.  
  3. /**
  4.  * @author : Laity
  5.  * @Project: JavaLaity
  6.  * @Package com.laity.basicSyntax.day1.bArray
  7.  * @date Date : 2021年11月13日 16:59
  8.  * @Description: 顺序查询
  9.  */
  10. public class FindElement7 {
  11.     public static void main(String[] args) {
  12.         int[] array = {1, 3, 5, 6, 9, 7, 2, 0, 10};
  13.         int index = indexOf(array, 50);
  14.         System.out.println(index);   // 返回索引
  15.     }
  16.  
  17.     /**
  18.      * 使用顺序查询，查询数组中指定的元素出现的下标
  19.      *
  20.      * @param array   需要去查询的数组
  21.      * @param element 需要查询的元素
  22.      * @return 元素出现的下表；如果元素不存在，则返回-1；
  23.      */
  24.     public static int indexOf(int[] array, int element) {
  25.         // 遍历数组中的每一个元素
  26.         for (int i = 0; i < array.length; i++) {
  27.             // 将每一个元素依次和要查询的元素进行比较
  28.             if (array[i] == element) {
  29.                 // 如果比较通过，则这个下标就是要查询的元素下标
  30.                 return i;
  31.             }
  32.         }
  33.         // 如果循环走完，还没有结果返回，那就说明这个元素不存在
  34.         // 不存在的元素，我们统一返回-1
  35.         return -1;
  36.     }

二分查询

  1. // 即利用数组中间的位置，将数组分为前后两个子表。如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
  2. // 二分查询，要求数组必须是排序的，否则无法使用二分查询。(就是已经排好序的:升序或者降序的)
  3.  
  4. package com.laity.basicSyntax.day2.bArray;
  5.  
  6. /**
  7.  * @author : Laity
  8.  * @Project: JavaLaity
  9.  * @Package com.laity.basicSyntax.day2.bArray
  10.  * @date Date : 2021年11月14日 11:34
  11.  * @Description: 二分查询
  12.  */
  13. public class BinarySearch {
  14.     public static void main(String[] args) {
  15.         int[] array = {1, 4, 6, 7, 8, 10, 12, 13};
  16.         int index = binarySearch(array, 10);
  17.         System.out.println(index);
  18.     }
  19.  
  20.     /**
  21.      * 从一个数组中，使用二分查询法，查询元素的下标
  22.      *
  23.      * @param array   需要查询的数组
  24.      * @param element 需要查询的元素
  25.      * @return 下标
  26.      */
  27.     public static int binarySearch(int[] array, int element) {
  28.         // 定义两个变量，分别记录范围的上线和下限
  29.         int min = 0, max = array.length - 1;
  30.  
  31.         while (max >= min) {
  32.             // 找到中间下标
  33.             int mid = (max + min) / 2;
  34.             // 判断中间的元素和要查询的元素的大小关系
  35.             if (array[mid] == element) {
  36.                 return mid;
  37.             } else if (array[mid] > element) {  // 查左边
  38.                 // 修改范围的上线
  39.                 max = mid - 1;
  40.             } else {
  41.                 // 修改范围的下限
  42.                 min = mid + 1;
  43.             }
  44.         }
  45.         // 如果循环走完了，依然没有结果返回，说明要查询的这个数据在数组中不存在
  46.         return -1;
  47.     }
  48. }

可变长参数

  1. // 概念:可以接收多个类型相同的参数，个数不限，使用方法与数组相同。
  2. // 在调用方法的时候，实参的数量可以写任意多个。     本质还是一个数组
  3. // 语法：数据类型... 形参名(必须放到形参列表的最后位，且只能有一个)
  4.  
  5. package com.laity.basicSyntax.day2.bArray;
  6.  
  7. /**
  8.  * @author : Laity
  9.  * @Project: JavaLaity
  10.  * @Package com.laity.basicSyntax.day2.bArray
  11.  * @date Date : 2021年11月14日 12:13
  12.  * @Description: 可变长度的参数列表
  13.  */
  14. public class MutipleParameter {
  15.     public static void main(String[] args) {
  16.         int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  17.         int Max = getMax(array);
  18.         System.out.println("最大值:" + Max);
  19.         int Min = getMin(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  // 可以这样写
  20.         System.out.println("最小值:" + Min);
  21.     }
  22.  
  23.     public static int getMax(int[] array) {
  24.         int max = array[0];
  25.         for (int element : array) {
  26.             if (element > max) {
  27.                 max = element;
  28.             }
  29.         }
  30.         return max;
  31.     }
  32.  
  33.     public static int getMin(int... arrays) {  // int... arrays 不等长参数的写法
  34.         int min = arrays[0];
  35.         for (int element : arrays) {
  36.             if (element < min) {
  37.                 min = element;
  38.             }
  39.         }
  40.         return min;
  41.     }
  42. }

二维数组

  1. // int[][] array3 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
  2.  
  3. package com.laity.basicSyntax.day2.bArray;
  4.  
  5. /**
  6.  * @author : Laity
  7.  * @Project: JavaLaity
  8.  * @Package com.laity.basicSyntax.day2.bArray
  9.  * @date Date : 2021年11月14日 14:28
  10.  * @Description: 二维数组
  11.  */
  12. public class Array2 {
  13.     public static void main(String[] args) {
  14.         // 二维数组的元素访问
  15.         // 1.实例化一个二维数组
  16.         int[][] array = new int[5][3];
  17.         // 2.获取数组中的小数组
  18.         int[] arr = array[1];
  19.         // 3.修改数组中的小数组
  20.         array[1] = new int[]{2, 3, 4, 5, 6, 7, 8};
  21.         System.out.println(array);
  22.         // 4.获取小数组中的数据
  23.         int ele = array[1][4];
  24.         System.out.println(ele);
  25.         // 5.修改小数组中的数据
  26.         array[2][2] = 3;
  27.         System.out.println(array);
  28.     }
  29.  
  30.     public static void initArray() {
  31.         // 1.二维数组的定义和实例化
  32.         // int[][] array;  // 声明一个二维数组，这个数组中，存储的每一个元素，都是一个小的一维数组
  33.  
  34.         // 1.1给定一个二维数组的长度，进行二维数组的实例化
  35.         // 此时这个二维数组中存储的元素是 null
  36.         int[][] array1 = new int[5][];
  37.         for (int[] ints : array1) {
  38.             System.out.println(ints);
  39.         }
  40.         // 1.2 给定一个二维数组的长度，同时给定一维数组的长度，进行实例化
  41.         //     此时，这个二维数组中存储的一维数组，已经完成了实例化了
  42.         //     这个3仅仅是初始的长度，后面可以改
  43.         int[][] array2 = new int[5][3];
  44.         System.out.println(array2);
  45.         // 1.3 通过指定的值，进行数组的实例化
  46.         int[][] array3 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
  47.         System.out.println(array3);
  48.         // 1.4 最简化
  49.         int[][] array4 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
  50.         System.out.println(array4);
  51.     }
  52. }

Arrays工具类

  1. // 里面包含了若干个对数组进行操作的工具方法
  2. // 工具方法:方便对数组进行操作的方法
  3.  
  4. package com.laity.basicSyntax.day2.bArray;
  5.  
  6. import java.util.Arrays;  // 导包
  7.  
  8. /**
  9.  * @author : Laity
  10.  * @Project: JavaLaity
  11.  * @Package com.laity.basicSyntax.day2.bArray
  12.  * @date Date : 2021年11月14日 15:00
  13.  * @Description: Arrays工具类
  14.  * 里面包含了若干个对数组进行操作的工具方法
  15.  * 工具方法:方便对数组进行操作的方法
  16.  */
  17. public class ArrayTools {
  18.     public static void main(String[] args) {
  19.         // System.arraycopy();
  20.         // 数组拷贝: 将一个数组中的指定位开始的元素拷贝到目标数组中的指定位，拷贝length长度的元素
  21.         // 注意事项:不要发生下标越界的情况
  22.         // arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);
  23.         // Object src: 原数组
  24.         // int srcPos: 原数组指定位开始拷贝位置
  25.         // Object dst: 目标数组
  26.         // int dstPos: 目标数组指定位开始拷贝位置
  27.         // int length: 拷贝的元素的数量  就是拷贝的长度
  28.         int[] src = {1, 3, 5, 7, 8, 9, 10};
  29.         int[] dst = {20, 30, 40, 50, 60, 70};
  30.         System.arraycopy(src, 1, dst, 1, 3);
  31.         System.out.println(Arrays.toString(dst));
  32.     }
  33.  
  34.     /**
  35.      * 基本工具的使用
  36.      */
  37.     public static void ArrayUsage() {
  38.         // 1.准备一个数组
  39.         int[] array = {1, 3, 5, 7, 8, 9, 10, 17};
  40.         int[] arr = {1, 3, 4, 7, 8, 9, 10, 17};
  41.         // 2.工具方法:
  42.         // 如果newLength超出了原数组的长度，依然可以拷贝，只是在最后的结果添加了 0
  43.         int[] ret = Arrays.copyOf(array, 5);  // 从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组
  44.  
  45.         // 2.1 将数组中的元素拼接成字符串返回
  46.         String ret1 = Arrays.toString(ret);   // 拼接成字符串返回
  47.         System.out.println(ret1);
  48.  
  49.         // 2.2 从原数组中拷贝指定的范围 [from, to) 的元素，到一个新的数组中，并且返回这个新的数组
  50.         // to 是可以越界的，后面会用0指定的位数，form是不可以越界的，否则会报异常的
  51.         int[] ret3 = Arrays.copyOfRange(array, 2, 7);
  52.         System.out.println(Arrays.toString(ret3));
  53.  
  54.         // 2.3 判断两个数组是否相同
  55.         boolean equals = Arrays.equals(array, arr);  // 这个有快捷键  .var
  56.         System.out.println(equals);
  57.  
  58.         // 2.4 使用指定的数据填充数组
  59.         Arrays.fill(array, 8);  // 将数组的所有元素都填充为8
  60.         System.out.println(Arrays.toString(array));
  61.  
  62.         // 2.5 对数组中的元素进行排序(升序排序)
  63.         Arrays.sort(array);
  64.         System.out.println(Arrays.toString(array));  // JDK排序
  65.  
  66.         // 2.6 使用二分查询法，查询数组中指定的元素出现的下标
  67.         int index = Arrays.binarySearch(array, 7);
  68.         System.out.println(index);
  69.     }
  70. }

数组的拓展功能

  1. package com.laity.basicSyntax.day2.bArray;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6.  * @author : Laity
  7.  * @Project: JavaLaity
  8.  * @Package com.laity.basicSyntax.day2.bArray
  9.  * @date Date : 2021年11月14日 23:45
  10.  * @Description: 数组中的拓展到功能
  11.  */
  12. public class ArrayExtension {
  13.     public static void main(String[] args) {
  14.         // 数组的扩容: 实例化一个新的指定长度的数组，将原来数组中的元素依次拷贝到这个新的数组中即可
  15.  
  16.         int[] original = {1, 4, 7, 8, 9};
  17.         // 需求:在现有元素的后面添加一个 0
  18.         // 1. 对original数组进行扩容，使其容量加1
  19.         int[] newArray = new int[original.length + 1];
  20.         // 2. 依次将original中的每一个元素拷贝到新的数组中
  21.         for (int i = 0; i < original.length; i++) {
  22.             newArray[i] = original[i];
  23.         }
  24.         // 3.将 0 放到newArray的最后一位
  25.         newArray[newArray.length - 1] = 0;
  26.         // 4.重定向original的地址指向
  27.         original = newArray;
  28.         // 5.遍历数组，输出数组中的所有的元素
  29.         System.out.println(Arrays.toString(original));  // [1, 4, 7, 8, 9, 0]
  30.  
  31.         int[] array = add(original, 10);
  32.         System.out.println(Arrays.toString(array));
  33.  
  34.         // array = remove(original, 3);
  35.         array = newRemove(original, 3);
  36.         System.out.println(Arrays.toString(array));
  37.     }
  38.  
  39.     /**
  40.      * 关于数组扩容的基本思路
  41.      */
  42.     public static void growup() {
  43.         // 关于数组扩容的基本思路
  44.  
  45.     }
  46.  
  47.     /**
  48.      * 希望将一个元素拼接到一个现有数组的最后
  49.      *
  50.      * @param array   现有的数组
  51.      * @param element 需要拼接的元素
  52.      * @return 添加元素之后的数组
  53.      */
  54.     public static int[] add(int[] array, int element) {
  55.         // 1. 对original数组进行扩容，使其容量加1
  56.         // 2. 依次将original中的每一个元素拷贝到新的数组中
  57.         array = Arrays.copyOf(array, array.length + 1);
  58.         // 3.将 element 放到newArray的最后一位
  59.         array[array.length - 1] = element;
  60.         // 4.返回拼接好的数组
  61.         return array;
  62.     }
  63.  
  64.     /**
  65.      * 需要从array数组中移除指定下标位的元素
  66.      *
  67.      * @param array   被操作的数组
  68.      * @param element 被删除元素的下标
  69.      * @return 返回删除元素之后的数组
  70.      */
  71.     public static int[] remove(int[] array, int element) {
  72.         if (element < 0 || element >= array.length) {
  73.             return array;
  74.         }
  75.         // 1.实例化一个新的数组，新数组的长度是原数组的长度-1
  76.         int[] newArray = new int[array.length - 1];
  77.         // 2.拷贝前后两部分的数据
  78.         System.arraycopy(array, 0, newArray, 0, element);
  79.         System.arraycopy(array, element + 1, newArray, element, array.length - 1 - element);
  80.         // 3.返回结果
  81.         return newArray;
  82.     }
  83.  
  84.     public static int[] newRemove(int[] array, int element) {
  85.         if (element < 0 || element >= array.length) {
  86.             return array;
  87.         }
  88.         // 用element位之后的元素依次向前覆盖
  89.         System.arraycopy(array, element + 1, array, element, array.length - 1 - element);
  90.         // 返回结果
  91.         return Arrays.copyOf(array, array.length - 1);
  92.     }
  93. }

数组的堆和栈

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. 重写父类的方法 父类的方法名回车即可
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/664135
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号