Java语言基础

常见对象

数组排序

冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值的元素就会出现在最大索引处；以此循环

//冒泡排序：public static void main(String[] args) {int[] arr={24, 69, 80, 57, 13};maopao(arr);System.out.println(Arrays.toString(arr));}private static void maopao(int[] arr) {//外层循环控制轮数：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 t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;}}}}
打印结果：[13，24，57，69，80]

选择排序
从0索引开始，依次和后面元素互相比较，小的往前放，第一次完毕，最小值出现在了最小索引处，以此循环。

//选择排序：
public static void main(String[] args) {int[] arr={24, 69, 80, 57, 13};choice(arr);System.out.println(Arrays.toString(arr));}private static void choice(int[] arr) {//外层循环控制轮数：for (int j = 0; j < arr.length - 1; j++) {for (int i = 1 + j; i < arr.length; i++) {if (arr[j] > arr[i]) {//交换位置int t = arr[j];arr[j] = arr[i];arr[i] = t;}}}}

直接插入排序
算法思路:直接插入排序,是一种简单的排序方法。它的基本操作是将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表。
假设有一组元素{k1,k2…,kn},排序开始就认为k1是一个有序序列,让k2插入上述表长为1的有序序列,使之成为一个表长为2的有序序列,然后让k3插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列。
例如:
原始数据：49,38,65,97,76,13,27
[49],38,65,97,76,13,27 从1索引开始插入
[38,49], ,65,97,76,13,27
[38,49,65] 97,76,13,27
[38,49,65,97] 76,13,27
[38,49,65,76,97]13,27
[13,27,38,49,65,76,97],27
[13,27,38,49,65,76,97]

//直接插入排序：
import java.util.Arrays;
public class Test {public static void main(String[] args) {int[] arr={10,8,7,6,5,12,0,-1,-12,0};//1. 用while 循环：for (int i = 0; i < arr.length; i++) {int j=i;while (j > 0 && arr[j] < arr[j - 1]) {int t=arr[j];arr[j]=arr[j-1];arr[j-1]=t;j--;}}System.out.println(Arrays.toString(arr));//2. 用for循环：for (int i = 1; i < arr.length; i++) {for (int j = i; j >0; j--) {if (arr[j]<arr[j-1]){int t=arr[j];arr[j]=arr[j-1];arr[j-1]=t;}}}System.out.println(Arrays.toString(arr));}
}

快速排序

快速排序算法思想：
a：分治法：比大小，再分区从数组中取出一个数，作为基准数。
b：分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。
c：再对左右区间重复第二步，直到各区间只有一个数。
挖坑填数
a：将基准数挖出形成第一个坑。
b：由后向前找比他小的数，找到后挖出此数填到前一个坑中。
c：由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
d：再重复执行2，3两步骤。
例如：将数组5391672408进行快速排序操作

元素	5	3	9	1	6	7	2	4	0	8
第一次挖坑	坑位1		坑位3		坑位5	坑位7	坑位6	坑位4	坑位2
第一次填充	0	3	4	1	2	5	7	6	9	8
…
…

//快速排序：
import java.util.Arrays;
public class Test {public static void main(String[] args) {int[] arr = {5, 3, 9, 1, 6, 7, 2, 4, 0, 8};new Demo4().quickSort(arr, 0, arr.length - 1);System.out.println(Arrays.toString(arr));}public void quickSort(int[] arr, int start, int end) {if (start < end) {//获取分区索引int index = getIndex(arr, start, end);//对左右两个分区 再进行同样的步骤 ，即是递归调用quickSort(arr, start, index - 1);//左半部分quickSort(arr, index + 1, end);//右半部分}}//快速排序：private int getIndex(int[] arr, int start, int end) {//start 默认是0//end 是数组长度-1int i = start;int j = end;//定义基准数int x = arr[i];//循环while (i < j) {//从右往左比较while (i < j && arr[j] >= x) {j--;}//从右往左找到比基准数小的数了后，填坑if (i < j) {//把这个数填到上一个坑位arr[i] = arr[j];i++;}//从左往右找while (i < j && arr[i] < x) {i++;}// 找比基准数大的数，找到后填坑if (i < j) {arr[j] = arr[i];j--;}}//当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分arr[i] = x; //把基准数填进去return i; //返回基准数所在位置的索引}
}

归并排序
分而治之，归并的思想：
先将一个数组从中间开始拆分成两个数组，然后一直拆分为只有一个数字的数组；再合并成一个有序数组；

//归并排序：
import java.util.Arrays;
public class Test {public static void main(String[] args) {int[] arr={8, 4, 5, 7, 6, 3, 1, 2};//归并排序：先将一个数组从中间开始拆分成两个数组，然后一直拆分为只有一个数字的数组；再合并成一个有序数组//拆分：chaifen(arr,0,arr.length-1);System.out.println(Arrays.toString(arr));}//实现拆分：private static void chaifen(int[] arr, int start, int end) {int mid=(start+end)/2;//中间索引if (start <end){chaifen(arr,start,mid);//拆左边chaifen(arr,mid+1,end);//拆右边guiBing(arr,start,mid,end);}}private static void guiBing(int[] arr, int startIndex, int midIndex, int endIndex) {//定义一个临时数组int[] arr1=new int[endIndex-startIndex+1];//定义拆分的左边数组起始索引int i=startIndex;//定义拆分的右边数组起始索引int j=midIndex+1;//定义临时数组的起始索引int index=0;//比较左右两个数组的元素大小，并存入临时数组while (i<=midIndex&&j<=endIndex){if (arr[i]<=arr[j]){arr1[index]=arr[i];i++;}else {arr1[index]=arr[j];j++;}index++;}//处理左边剩余元素while (i<=midIndex){arr1[index]=arr[i];i++;index++;}//处理右边剩余元素while (j<=endIndex){arr1[index]=arr[j];j++;index++;}//将临时数组元素取到原数组中for (int y = 0; y < arr1.length; y++) {arr[y+startIndex]=arr1[y];}}
}

二分查找
查找数组的元素对应索引，前提是一个有序数组！将数组从中间分为两部分

//二分查找：
public static void main(String[] args) {int[] arr = {10, 20, 30, 40, 50, 60, 70};int a=getIndex(arr,50);System.out.println("索引为："+a);}private static int getIndex(int[] arr, int ele) {int minIndex = 0;//定义最小索引int maxIndex = arr.length - 1;//定义最大索引int centerIndex = (minIndex + maxIndex) / 2;//定义中间索引while (minIndex <= maxIndex) {if (ele == arr[centerIndex]) {//当查找元素与中间索引相同时return centerIndex;} else if (ele > arr[centerIndex]) {//当查找元素大于中间索引时minIndex = centerIndex + 1;} else if (ele < arr[centerIndex]) {//当查找元素小于中间索引时maxIndex = centerIndex - 1;}//重新计算中间索引centerIndex = (minIndex + maxIndex) / 2;}return -1;}
打印结果为：索引为：4

Arrays类

Arrays类概述：
针对数组进行操作的工具类。
提供了排序，查找等功能。
成员方法：
public static String toString(int[] a)：将某个类型转换为[ ]类型的字符串
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)

//toString的源码：
public static String toString(int[] a) {if (a == null)return "null";int iMax = a.length - 1;if (iMax == -1)return "[]";StringBuilder b = new StringBuilder();b.append('[');for (int i = 0; ; i++) {b.append(a[i]);if (i == iMax)return b.append(']').toString();b.append(", ");}}

基本类型包装类

为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型。
常用操作: 常用的操作之一，用于基本数据类型与字符串之间的转换。
基本类型和包装类的对应：

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类

Integer类概述：
Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。
构造方法：
public Integer(int value)
public Integer(String s)

自动装箱和拆箱

自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
JDK5的新特性
注意事项：
在使用时，Integer x = null;代码就会出现NullPointerException；建议先判断是否为null，然后再使用。

//有关Integer127，128问题：
public static void main(String[] args) {Integer.valueOf(127);//手动装箱Integer integer1=127;//自动装箱Integer integer2=127;System.out.println(integer1==integer2);//trueInteger integer3=128;Integer integer4=128;System.out.println(integer3==integer4);//false}

//valueOf的源码：public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}
/*
*Java中定义 int low = -128;
*还有一个算法：h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
*令 high = h;
*故自动装箱为int 数据为127，128 就会产生上面代码的情况.
*/

//下篇再见…再见

Java语言基础（常见对象3（数组排序（冒泡排序、选择排序、直接插入排序、快速排序、归并排序）、Arrays、基本数据类型包装类、Integer类、自动拆箱、自动装箱））相关推荐

自动拆箱自动装箱以及String 和基本数据类型封装类生成的对象是否相等
自动拆箱(unboxing)&自动装箱(boxing) @author 李东秀|| qq:1028659927 本文主要为自己理解所做的学习笔记,如有不对的地方, 望各位看官不吝指出,代码运行 ...
java中的自动拆箱和装箱(以及NEP问题)
java中的自动拆箱和装箱 1.回顾知识点 java中的8种基本数据类型,可以分为三类字符类型 char 布尔类型 boolean 整数类型 byte , short , int , long 浮点 ...
java装箱和拆箱的意义_java的自动拆箱和装箱是每个程序员都要知道的
自动装箱和拆箱问题是Java中一个老生常谈的问题了,今天我们就来一些看一下装箱和拆箱中的若干问题.本文先讲述装箱和拆箱最基本的东西. 自动装箱和拆箱从Java 1.5开始引入,目的是将原始类型值转自动 ...
java double 装箱_Java自动拆箱和装箱
一.什么是装箱/拆箱在讲之前,得先提一下为什么两个概念:基本数据类型及其包装类,我们都知道Java是一种面向对象的语言,但是Java中的基本数据类型是不面向对象的,这时在使用中便会存在诸多的不便,为 ...
java 基本数据类型的自动拆箱与装箱
--> -128~127之间的特殊性.为什么要这样设计,好处? --> 享元模式(Flyweight Pattern):享元模式的特点是,复用我们内存中已存在的对象,降低系统创建对象实 ...
第三次学JAVA再学不好就吃翔(part59)--冒泡排序选择排序以及二分查找
学习笔记,仅供参考文章目录数组高级冒泡排序数组高级选择排序二分查找法数组高级冒泡排序冒泡排序原理:设数组中有n个元素,从第一个元素开始,对相邻元素进行两两比较,两个元素中大的往后放,第一次 ...
【C语言】排序算法（冒泡排序，选择排序，插入排序，归并排序，快速排序）
时间复杂度: 冒泡排序(n²),选择排序(n²),插入排序(n ~ n²),归并排序(nlbn),快速排序(nlbn ~ n²) 下面都是将已定数组{28,25,20,40,16,30,18,46,4 ...
c语言排序需要插空的最小次数,C语言数组排序——冒泡排序、选择排序、插入排序...
一.冒泡排序原理解析:(以从小到大排序为例)在一排数字中,将第一个与第二个比较大小,如果后面的数比前面的小,则交换他们的位置. 然后比较第二.第三个--直到比较第n-1个和第n个,此时,每一次比较都 ...
c语言数组项目按身高排序,过三关 Java冒泡排序选择排序插入排序小练习
材料:猴子排序,按照身高来从小到大来排序. 第一关: 老猴子带领小猴子队伍按大小逐一比较,交换,开始高矮排列队伍.(冒泡排序) 第二关: 太慢了,给第一关增加难度,进行选择排序第三关: 最后,尝试选 ...

Java语言基础（常见对象3（数组排序（冒泡排序、选择排序、直接插入排序、快速排序、归并排序）、Arrays、基本数据类型包装类、Integer类、自动拆箱、自动装箱））

Java语言基础

常见对象

数组排序

Java语言基础（常见对象3（数组排序（冒泡排序、选择排序、直接插入排序、快速排序、归并排序）、Arrays、基本数据类型包装类、Integer类、自动拆箱、自动装箱））相关推荐

最新文章

热门文章