黑马程序员——常用API——数组高级,Arrays,Integer

最新推荐文章于 2022-07-04 10:38:09 发布

hison_lian

最新推荐文章于 2022-07-04 10:38:09 发布

阅读量392

点赞数

分类专栏： java学习日志

本文链接：https://blog.csdn.net/hison_lian/article/details/45896521

版权

java学习日志专栏收录该内容

17 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一.数组的高级操作

1.数组就是存储相同数据类型的多个元素的容器。

2.特点是每个元素都有从0开始编号的索引,最后一个索引是length-1.

3.数组操作：

A:遍历

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;"><span style="white-space:pre">			</span>public static void printArray(int[] arr) {
				for(int x=0; x<arr.length; x++) {
					System.out.print(arr[x]+" ");
				}
			}</span></strong></span>

B:获取最大值

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="white-space:pre">			</span>public static int getMax(int[] arr) {
				int max = arr[0];


				for(int x=1; x<arr.length; x++) {
					if(arr[x]>max) {
						max = arr[x];
					}
				}


				return max;
			}
</strong></span>

C:排序

a:冒泡排序
原理：相邻元素做比较，大的元素放后边。第一次完毕，最大值在最大索引处,
同理，其他的元素也这样排好。

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="white-space:pre">				</span>public static void bubbleSort(int[] arr) {
					for(int x=0; x<arr.length-1; x++) {
						for(int y=0; y<arr.length-1-x; y++) {
							if(arr[y] > arr[y+1]) {
								int temp = arr[y];
								arr[y] = arr[y+1];
								arr[y+1] = temp;
							}
						}
					}
				}
</strong></span>

b:选择排序
原理：从0索引元素开始，依次和后面的所有元素比较，小的往0索引处放。
第一次比较完毕后，最小值在最小索引处。同理，其他的元素也这样排好。

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="white-space:pre">				</span>public static void selectSort(int[] arr) {
					for(int x=0; x<arr.length-1; x++) {
						for(int y=x+1; y<arr.length; y++) {
							if(arr[y]>arr[x]) {
								int temp = arr[y];
								arr[y] = arr[x];
								arr[x] = temp;
							}
						}
					}
				}
</strong></span>

D:查找

a:普通查找(一般在数组无序的情况下使用)
原理：遍历数组，依次从头找到尾

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="white-space:pre">				</span>public static int getIndex(int[] arr,int value) {
					int index = -1;


					for(int x=0; x<arr.length; x++) {
						if(arr[x]==value) {
							index = x;
							break;
						}
					}


					return index;
				}
</strong></span>

b:二分查找法(一般在数组有序的情况下使用)
前提：数组必须是从小到大排过序的

原理：每次都从中间开始找，如果比中间数据小，就在左边找，
如果比中间数据大，就在右边找，如果相等，就返回中间的索引值。

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="white-space:pre">				</span>public static int getIndex(int[] arr,int value) {
					int start = 0;
					int end = arr.length-1;
					int mid = (start+end)/2;


					while(arr[mid]!=value){
						if(value>arr[mid]) {
							start = mid + 1;
						}else if(value<arr[mid]) {
							end = mid - 1;
						}


						if(start > end) {
							return -1;
						}


						mid = (start+end)/2;
					}


					return mid;
				}
</strong></span>

二.Arrays工具类的使用

1.Arrays是专门针对数组数据进行操作的工具类。

2.主要功能：

A:把数组转成字符串
public static String toString(int[] arr)

B:排序
public static void sort(int[] arr)

C:二分查找
public static int binarySearch(int[] arr,int value)

三.StringBuffer类与StringBuilder类

1.StringBuffer:是字符串缓冲区类，容量可以改变。

2.简答题：

A:String和StringBuffer的区别?

String的长度是固定。
StringBuffer的长度可以改变。

StringBuffer和StringBuilder的区别?

StringBuffer与StringBuilder的功能一致.
StringBuffer的线程安全,效率低。
StringBuilder的线程不安全,效率高。

3.StringBuffer的构造方法
A:StringBuffer sb = new StringBuffer();
B:StringBuffer sb = new StringBuffer(int capacity);
C:StringBuffer sb = new StringBuffer(String s);

注意：StringBuilder的功能和StringBuffer一模一样。StringBuilder是JDK5以后出现的。
4.主要功能
A:添加功能 public StringBuffer append(int a)
B:删除功能 public StringBuffer delete(int start,int end)
C:其他功能
替换功能 public StringBuffer replace(int start,int end,String str)
截取功能 public StringBuffer subString(int start,int end)
反转功能 public StringBuffer reverse()
5.练习:
把一个字符串反转。

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.day13;


		//把一个字符串反转输出  "abcde"
public class Test5 {
	public static void main(String[] args) {
		String s = "abcde";
		// 将字符串转化为字符数组
		char[] arr = s.toCharArray();
		// 倒着遍历数组
		for (int i = arr.length - 1; i >= 0; i--) {
			System.out.print(arr[i]);
		}
		
	}
}</span></strong></span>

四.基本数据类型包装类

1.之前我们对基本类型只能做一些最简单的操作，
为了让我们有更多的操作，java就针对每种基本类型提供了保证类。

2.八种基本类型对应的包装类

byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

3.Integer类的构造方法

A:Integer i = new Integer(int x);
B:Integer i = new Integer(String s);
s必须是由数字字符组成的字符串

4.Integer的功能

A:String -- int
String s = "34";
int i = Integer.parseInt(s);

B:int -- String
int i = 54;
String s = String.valueOf(i);

5.JDK5以后的新特性

A:自动装箱从int--Integer
B:自动拆箱从Integer--int

下面的代码：哪里体现了自动装箱，哪里体现了自动拆箱
Integer i = 100;//赋值操作体现了自动装箱
i += 200; //首先参与运算体现了自动拆箱,后赋值操作体现了自动装箱
System.out.println(i);

6.练习1：
byte缓冲池

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.day13;
/*
 * 基本类型包装类的注意事项：
 * 		使用自动拆箱进行数据计算时，需要注意滤空操作。
 * 		java虚拟机为了优化8种基本数据类型的包装对象都提供了缓冲池,缓冲池有大小,一个字节。
 * 		当数值在一个字节内时，不再创建新的对象，而使用缓冲池中已经存在的对象。
 * 		当数值超过一个字节会创建新的对象。
 */
public class Demo9 {


	public static void main(String[] args) {


		
		Integer i1 = new Integer(127);
		Integer i2 = new Integer(127);
		System.out.println(i1 == i2);


		Integer i3 = new Integer(128);
		Integer i4 = new Integer(128);
		System.out.println(i3 == i4);


		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);


		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);


	}


}
</span></strong></span>

因为一个字节只能代表-128-127,所以超过127的都会重新创建对象.
运行结果是
false
false
false
true

7.练习2：
把字符串"34 -12 56 93 27"中的数据排序并输出。

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.day13;



//把字符串"34 -12 56 93 27"中的数据排序，然后输出排序后的字符串。
public class Test4 {
	public static void main(String[] args) {
		String s = "34 -12 56 93 27";
		sortString(s);
	}


	private static void sortString(String s) {
		// 首先将字符串进行分割为字符串数组
		String[] arr = s.split(" ");
		// 定义int数组
		int[] arri = new int[arr.length];
		// 将数组进行遍历并转换为int类型
		for (int i = 0; i < arr.length; i++) {
			String string = arr[i];
			// 将字符串转化为int值
			int temp = Integer.parseInt(string);
			// 将int值装入int数组
			arri[i] = temp;


		}
		// 将int数组进行排序
		for (int i = 0; i < arri.length - 1; i++) {
			for (int j = i + 1; j < arri.length; j++) {
				if (arri[i] > arri[j]) {
					int temp = arri[i];
					arri[i] = arri[j];
					arri[j] = temp;


				}
			}
		}
		// 遍历排序后的数组
		for (int i = 0; i < arri.length; i++) {
			System.out.print(arri[i] + " ");
		}
	}
}</span></strong></span>

hison_lian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——常用API——数组高级,Arrays,Integer

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------一.数组的高级操作1.数组就是存储相同数据类型的多个元素的容器。2.特点是每个元素都有从0开始编号的索引,最后一个索引是length-1.3.数组操作：A:遍历 public static void printArray(int[] arr)
复制链接

扫一扫