Java_从入门到JavaEE_07

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量1.3k 收藏 21
点赞数 33
文章标签： java java-ee 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lv785/article/details/138328132
版权

一、数组的排序（冒泡排序）

  1. 原理：

    从下标“0”开始，相邻两个元素依次进行比较，每次找出最大的往后移动。

  2. 规律：N个数字来排队，两两相比小靠前，外层循环N-1，内层循环N-1-i。

  3. 案例：对一组数组进行排队

    public class Test{
    public static void main(String[] args){
        int[] arr={5,6,2,7,8,3,1,9};
        
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int element:arr){
            System.out.println(element);
        }
    }
}

    ps:排序只需要了解熟悉就行，因为在平常的Java开发中有专门的的工具类Arrays，所以排序一般只有在面试的时候可能会用到。

二、数组的查找

1.线性查找

  1. 线性查找就是用for循环进行遍历。

  2. 案例：

    import java.util.Scanner;
public class Test{
    public static void main(String[] args){
         int[] arr={5,6,2,7,8,3,1,9};
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入需要查询的元素：");
        int num=scan.nextInt();
        
        for(int i=0;i<arr.length;i++){
            if(num==arr[i]){
                System.out.println("你查询的元素的下标为："+i);
            }
        }
    }
}

    缺点：由于它是从首位开始依次进行查找的所以当数组中的元素过多是会影响查询的速度。

2.二分法/二叉查找

  1. 二分法是先将数组进行排序，然后确定三个下标：首位（start），最后一位（end），中间一位（（start+end）/2=mid）ps：如果计算出现小数会自动省略，当中间位元素大于需查询的元素：end=mid-1，反之start=mid+1。

  2. 案例：

    import java.util.Arrays;
import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        int[] arr={5,6,2,7,8,3,1,9};
        Arrays.sort(arr);//排序
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入需要查询的元素：");
        int num=scan.nextInt();
        
        int start=0;
        int end=arr.length-1;
        while(start<=end){
            int mid =(start+end)/2;
            if(num<	arr[mid]){
                end=mid-1;
            }else if(num>arr[mid]){
                start=mid+1;
            }else{
                System.out.println("你查询的元素的下标为："+mid);
                break;
            }
        }
    }
}

三、数组扩展

1.数组的复制

  1. 浅表赋值

  2. 案例：

    public class Test04{
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"张三","李四","王五"};
		
		//新数组
		String[] newArr = arr;
		
		//修改原数组
		arr[1] = "赵六";
		
		//遍历新数组
		for(String element : newArr){
			System.out.println(element);
		}
		
	}
}

    缺点：修改原数组，新数组中的数据也会发生改变

    原理：在这里插入图片描述

  3. 深表赋值

  4. 案例：

    public class Test05{
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"张三","李四","王五"};
		
		//新数组
		String[] newArr = new String[arr.length];
		
		//将原数组下标的元素赋值给新数组
		for(int i = 0;i<arr.length;i++){
			newArr[i] = arr[i];
		}
		
		//修改原数组
		arr[1] = "赵六";
		
		//遍历新数组
		for(String element : newArr){
			System.out.println(element);
		}
		
	}
}

    原理：

    在这里插入图片描述

2.数组的扩容

  1. 案例：

    public class Test06{
	public static void main(String[] args){

		//原数组
		String[] arr = {"张三","李四","王五"};
		
		//计算新容量
		int oldCapacity = arr.length;//3
		int newCapacity = oldCapacity + (oldCapacity>>1);//4
		
		//新数组
		String[] newArr = new String[newCapacity];
		
		//将原数组下标的元素赋值给新数组
		for(int i = 0;i<arr.length;i++){
			newArr[i] = arr[i];
		}
		
		//将新数组的地址赋值给原数组
		arr = newArr;
		
		//遍历原数组
		for(String element : arr){
			System.out.println(element);
		}
		
	}
}

3.数组的删除

  1. 方法一案例：

    public class Test{
	public static void main(String[] args){
		//原数组
		String[] arr = {"张三","李四","王五","赵六"};
		//新数组
		String[] newArr = new String[arr.length-1];//3 - [null,null,null]
		
		int index = 0;
		for(String element : arr){
			if(!element.equals("李四")){
				newArr[index++] = element;
			}
		}
		
		//将新数组的地址赋值给原数组
		arr = newArr;
		
		//遍历原数组
		for(String element : arr){
			System.out.println(element);
		}
		
	}
}

    缺点：数组作为容器，是存储数据的，这样的删除会让容器越变越小

  2. 方法二

    public class Test{
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"张三","李四","王五","赵六"};
		
		//将删除元素后一位的数据全部都往前移 
		for(int i = 1;i<arr.length-1;i++){
			arr[i] = arr[i+1];
		}
		
		//将最后一位数据赋值为null
		arr[arr.length-1] = null;
		
		//遍历原数组
		for(String element : arr){
			System.out.println(element);
		}
		
	}
}

4.数组作为方法的参数和返回值

案例：设计一个方法，传入int类型的数组，返回最大值和最小值

public class Test{
	public static void main(String[] args){
		
		int[] arr = {5,78,55,26,23,51,32};
		
		int[] newArr = getMaxAndMin(arr);
		System.out.println("最大值为：" + newArr[0]);
		System.out.println("最小值为：" + newArr[1]);
	}
	
	public static int[] getMaxAndMin(int[] arr){
		
		int max = arr[0];
		int min = arr[0];
		
		for(int i = 1;i<arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
			if(min > arr[i]){
				min = arr[i];
			}
		}
		
		int[] maxAndMin = {max,min};
		return maxAndMin;
	}
	
}

5.可变参数

案例：设计一个方法，传入n个int类型的值，返回最大值

public class Test{
	public static void main(String[] args){
		
		int max = getMax(1,2,3,4,5,6,7);//将实参作为数组的元素传入
		System.out.println(max);
	}
	
	//int... arr -- 可变参数，实际上就是数组
	public static int getMax(int... arr){
		if(arr.length == 0){//意味着实参没有传任何数据
			return -1;
		}
		int max = arr[0];
		for(int i = 1;i<arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
		}
		return max;
	}
}

注意：可变参数后不能接其他参数

四、Arrays工具类

  1. 理解：Arrays是Java给我们提供的专门用于操作数组的工具类

  2. 概念：

    1. 工具类 – 该类中的方法都是静态的，直接使用类名调用
    2. API ----- Java提供类的说明书

  3. 案例：

    import java.util.Arrays;
public class Test{
	public static void main(String[] args){
			
		int[] arr = {5,72,9,4,21,1,6,3,81};	
		
		//排序 - 1,3,4,5,6,9,21,72,81
		Arrays.sort(arr);
		
		//查找
		//返回值规则：搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 
		//返回值规则：如果元素包含在数组中，返回下标;否则，(-(插入点) - 1) 
		int index = Arrays.binarySearch(arr,30);
		System.out.println("查找到元素的下标为：" + index);
		
		//拷贝数组 
		int[] newArr1 = Arrays.copyOf(arr,15);
		
		//拷贝数组区间 
		int[] newArr2 = Arrays.copyOfRange(newArr1,2,11);//(目标数组，开始下标-包含，结束下标-排他)
		
		//替换所有元素
		Arrays.fill(newArr2,888);
		
		//替换区间元素
		Arrays.fill(newArr2,2,4,666);//(目标数组，开始下标-包含，结束下标-排他，替换元素)
	
		//将数组转换为字符串
		String str = Arrays.toString(newArr2);
		System.out.println(str);
	}
}

五、二维数组

  1. 理解：二维数组包含了多个一维数组

  2. 数组的声明：

    1. 数据类型[][] 数组名;00
    2. 数据类型 数组名[][];

  3. 静态初始化

    案例：

public class Test{
	public static void main(String[] args){
		
		//静态初始化1
		//String[][] names = new String[][]{{"小明","小红","小绿"},{"张三","李四","王五","赵六"}};
		
		//静态初始化2
		//String[][] names;
		//names = new String[][]{{"小明","小红","小绿"},{"张三","李四","王五","赵六"}};
		
		//静态初始化3
		String[][] names = {{"小明","小红","小绿"},{"张三","李四","王五","赵六"}};
		
		//设置指定下标上的元素
		names[0][1] = "星星";
		
		//获取指定下标上的元素
		String str = names[0][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的长度：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的长度：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的长度：" + names[1].length);//4
		
		System.out.println("------------------------------------");
		
		//遍历思路：循环遍历出一维数组，再循环遍历一维数组的元素
		
		//遍历数组 -- for循环
		for(int i = 0;i<names.length;i++){
			for(int j = 0;j<names[i].length;j++){
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("------------------------------------");
		
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	
	}
}

  1. 案例1：动态初始化

    public class Test{
public static void main(String[] args){
		
		//动态初始化1
		//String[][] names = new String[2][3];//2表示2个一维数组，3表示每个一维数组有3个元素
		
		//动态初始化2
		String[][] names;
		names = new String[2][3];//2表示2个一维数组，3表示每个一维数组有3个元素
		
		//设置指定下标上的元素
		names[0][1] = "小红";
		
		//获取指定下标上的元素
		String str = names[0][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的长度：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的长度：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的长度：" + names[1].length);//4		
		//遍历思路：循环遍历出一维数组，再循环遍历一维数组的元素
		//遍历数组 -- for循环
		for(int i = 0;i<names.length;i++){
			for(int j = 0;j<names[i].length;j++){
				System.out.println(names[i][j]);
			}
		}
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	
	}
}

  2. 案例2：使用动态初始化声明二维数组，二维数组中有两个一维数组，第一个一维数组有3个元素 ，第二个一维数组有4个元素

    public class Test{
	public static void main(String[] args){
		
		String[][] names = new String[2][];
		
		String[] s1 = {"aaa","bbb","ccc"};
		String[] s2 = {"ddd","eee","fff"};
		
		names[0] = s1;
		names[1] = s2;
		
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	}
}

动态初始化声明二维数组，二维数组中有两个一维数组，第一个一维数组有3个元素 ，第二个一维数组有4个元素

public class Test{
	public static void main(String[] args){
		
		String[][] names = new String[2][];
		
		String[] s1 = {"aaa","bbb","ccc"};
		String[] s2 = {"ddd","eee","fff"};
		
		names[0] = s1;
		names[1] = s2;
		
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	}
}

底层原理：在这里插入图片描述

静风残云
关注
Java 从入门到精通全程笔记(JavaSE+JavaEE :史上最全笔记）
11-28
JavaSE+JavaEE企业级开发 全程笔记免费下载，内容详尽，doc文档,共173页,六号字体，双栏排版。 *、Java 基础， *、web， *、数据库（Mysql Oracle jdbc Hibernate hql/sql）， *、JSP， *、Ajax *、Struts， *、...
从java走向javaEE
11-23
总而言之，《从Java走向JavaEE》是一本适合初学者的入门书籍，它将引导读者从简单的Java编程逐渐过渡到复杂的JavaEE企业级应用开发。通过实践书中的代码示例，读者可以巩固理论知识，提高实际开发能力。然而，要想在...
Java_从入门到JavaEE_11
lv785的博客
05-08 1451
接口不可以new对象，接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象。接口里面的方法不一定都是抽象的，JDK1.8之前：接口中只能有静态常量和抽象方法，JDK1.8开始：接口中可以使用默认方法和静态方法。如果父类是抽象类，子类不一定实现父类的抽象方法，子类如果是抽象类，可以不实现父类的抽象方法。理解：实现类对象指向接口的引用（接口的引用中存储的是实现类对象在堆中开辟的地址）一个接口不可以实现多个接口，因为接口与接口的关系是多继承。
Java_从入门到JavaEE_15
lv785的博客
05-14 1219
虽然使用其它的 Map 实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用 EnumMap 会更加高效，因为它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值。尽管枚举看起来像是一种新的数据类型，实际上，枚举就是一种受限制的类，并且具有自己的方法。（枚举类编译时，没有把常量值编译到代码中，即使常量值发生改变，也不会影响引用常量的类 ）优点：这种枚举通过枚举嵌套枚举的方式，将枚举常量分类处理。
Java_从入门到JavaEE_14
lv785的博客
05-13 998
含义：用来描述或者匹配一系列符合某个语句规则的字符串案例：把一个字符串中带电话号码替换成111****1234总结：利用正则表达式对字符串进行替换，校验，分割，爬数据。常用表达式：见正则表达式常用表达式。
Java_从入门到JavaEE_19
lv785的博客
05-18 885
在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用出进行处理。JDK新特性，一个catch代码可以可以声明多个能处理的特定异常的类型，多个类型之间用”|”隔开。写catch代码时，先捕获的异常的范围不能大于后捕获的异常的范围。定义一个方法的时候，通过这种方式来告知调用方，我这个方法有可能会发生异常的。注意：此时抛出的是异常类型，并且抛出的异常类型是紧跟在方法名之后。当异常发生时，程序会中止当前的流程去执行相应的catch代码段。
Java_从入门到JavaEE_18
lv785的博客
05-17 370
JDK1.8版本的HashMap，数据结构是一维数组+单向链表+红黑树，获取hash值使用高16位^低16位，尾插法。多个key的hash值一样，意味着下标也是一样，在底层就会将多个key存储在一个单向链表里，效率极低。JDK1.7版本的HashMap，数据结构是一维数组+单向链表，获取hash值使用位移计算，头插法。因为不用的字符串的hash值有可能相同，会造成hash碰撞，所以hash种子数就应运而生了~~计算hash值是 数组长度-1 & key的hash值，2的幂长度会导致下标结果分布更加散列。
Java_从入门到JavaEE_04-1
lv785的博客
04-25 287
含义：具有特殊意义的字符本身。
Java_从入门到JavaEE_12+13
lv785的博客
05-10 1471
深入：现在的需求要存储10000个长度的数据，不要使用new StringBuilder()的方式，因为使用无参构造，底层会创建16长度的容器，存储10000个数据需要多次扩容，效率极低，直接使用new StringBuilder(10000)的方式，一步到位。​ Java为纯面向对象语言（万物皆对象），但是8种基本数据类型不能new对象，破坏了Java为纯面向对象语言的特征，所以Java又为8种基本你数据类型分别匹配了对应的类，这种类叫做包装类/封装类。案例：创建成员内部类的对象，并调用方法。
Java_从入门到JavaEE_08
lv785的博客
05-01 1030
Eclipse工具简绍Eclipse 是著名的跨平台的自由集成开发环境（IDE）。最初主要用来 Java 语言开发，但是目前亦有人通过插件使其作为其他计算机语言比如 C++ 和 Python 的开发工具。下载与安装下载：安装：因为Eclipse为绿色软件，直接解压缩运行.exe就行。打开问题：下载包一般不会出问题，Eclipse打不开一般有两方面的问题：电脑中JDK设置的环境变量有问题，Eclipse无法正确找到。下载的Eclipse版本，和电脑安装JDK版本不兼容。
Java_从入门到JavaEE_01
lv785的博客
04-24 246
​ 接受来自客户端的请求、处理业务、操作数据库、利用相应向客户端换回数据的技术叫做JavaEE.​ 1、JDK：Java开发工具包​ 2、JRE：Java运行环境。
Java_从入门到JavaEE_16
lv785的博客
05-15 1385
一、迭代器 1.Iterator 概念：Iterator是一个接口，它是集合的迭代器，集合可以通过Iterator去遍历集合中的元素，常用API接口： hasNext():如果迭代器中还有元素，则返回true。 next():返回迭代器中的下一个元素。 remove():删除迭代器新返回的元素。 案例：使用Iterator遍历元素 public class Test { public static void main(String[] args) { ArrayList<St
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 136
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 813
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 870
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 252
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 410
函数式接口与回调函数
Java复习24（PTA)
2301_79272475的博客
10-30 408
Java复习24（PTA)：多种排序的book类*
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 286
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
Java/JavaEE学习全集：从入门到精通
"这是一份综合性的Java/JavaEE学习笔记，涵盖了从基础的Java语法到进阶的JavaEE技术，以及Unix操作系统的基础知识、Oracle数据库的使用等内容，旨在帮助读者成为成功的J2EE程序员。" 这篇笔记首先介绍了Java/JavaEE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值