Java数组的特点
优点：可以通过索引值访问任何的数组元素, 可以实现随机的访问。
缺点：插入/删除元素时, 需要扩容, 复制或者移动大量的元素, 效率比较低。
应用场景：适用于以查询访问为主, 很少进行插入/删除操作的情况。
import java.util.Arrays;
/**
* 在数组中插入元素
*
*
*/
public class Test01 {
public static void main(String[] args) {
int [] data = {1,2,3,4,5,6,7};
//在data数组,索引值为3的位置插入元素666
data = insert( data, 3 , 666);
System.out.println( Arrays.toString(data)); //[1,2,3,666,4,5,6,7]
}
//定义方法, 在数组的指定i位置添加一个元素key
public static int[] insert( int [] myArray, int i, int key) {
//1)定义更大的数组
int[] newData = new int[myArray.length+1];
//2) 把[0,i)范围的元素复制到新的数组中
for(int j = 0 ; j < i ; j++){
newData[j] = myArray[j];
}
//3) 把key元素存储到新数组的i位置
newData[i] = key;
//4) 把原数组[i,lenth)范围的元素复制到新的数组的[i+1, length+1)
for( int j = i ; j<myArray.length; j++){
newData[j+1] = myArray[j];
}
// //5) 让原来的数组名指向新的数组
// myArray = newData;
// System.out.println( Arrays.toString(myArray));
//5)返回新的数组
return newData;
}
}
//定义方法,删除数组指定位置的元素, 把myArray[i]元素删除
public static int[] delete(int [] myArray, int i) {
//1)定义更少的数组
int [] newData = new int[myArray.length-1];
//2) 把[0,i)范围 元素复制到新数组中
System.arraycopy(myArray, 0, newData, 0, i);
//3) 把[i+1, length)范围的元素复制到新数组[i,lenth-1)
for( int j = i+1; j < myArray.length; j++){
newData[j-1] = myArray[j];
}
//4) 返回新的数组
return newData;
}
Java对象数组
数组中存储元素的类型是引用类型
/**
* 对象数组
* 数组元素是一个对象, 数组中存储的是引用类型数据
* 数组元素实际上存储的是对象的引用
* 遍历对象数组,访问对象的实例成员时, 注意避免出现空指针异常
*
*
*/
public class Test02 {
public static void main(String[] args) {
//定义数组,存储5个Person对象
Person[] personss = new Person[5];
//给数组的元素赋值, 实际上是把对象的引用保存到数组元素中
Person lisi = new Person("lisi", 18);
personss[0] = lisi;
personss[2] = new Person("feifei", 28);
//遍历数组,输出每个元素
for( int i = 0 ; i<personss.length; i++){
System.out.println( personss[i] );
}
//让数组中的所有人吃饭, 遍历数组中的Person对象, 调用eat()
for (Person person : personss) {
if ( person != null ) {
person.eat();
}
}
}
}
class Person{
String name;
int age;
//吃饭
public void eat() {
System.out.println(name + "正在吃饭....");
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
Java二维数组
import java.util.Arrays;
/**
* 二维数组
* 数组的每个元素是一个一维数组, 即一维数组的数组
*
*
*
*/
public class Test03 {
public static void main(String[] args) {
int [] data1 = {1,2,3,4,5};
int [] data2 = {6,7,8};
int x = 10;
int y = 20;
int [] data3 = {x, y};
/*
* data1/data2/data3是三个数组名, 其实就是一个变量名, 它的数据类型是 int[] 类型
* []表示data1/data2/data3是数组, []前面的int表示数组元素的类型
* 数据类型[] 数组名 = new 类型[长度]
*/
//定义一个数组, 数组中存储data1, data2, data3这三个变量
int[] [] mydata = {data1, data2, data3};
//mydata是一个数组名, mydata前面的一个[]表示数组, []前面的int[]表示mydata数组中的元素类型
System.out.println( mydata.length ); //3
//遍历mydata数组中存储的整数
for( int i = 0 ; i<mydata.length; i++){
//mydata[0]是 data1, mydata[i]是一个一维数组名
// System.out.println( mydata[i] );
for( int j = 0 ; j < mydata[i].length ; j++){
System.out.print( mydata[i][j] + "\t" );
}
System.out.println();
}
//foreach遍历
for (int[] is : mydata) {
for (int xx : is) {
System.out.print( xx + "\t");
}
System.out.println();
}
//Arrays.deepToString()可以把多维数组中的元素转换为字符串
System.out.println( Arrays.deepToString(mydata));
}
}
import java.util.Arrays;
/**
* 二维数组的动态初始化及静态初始化
*
*
*/
public class Test04 {
public static void main(String[] args) {
//1)二维数组的动态初始化
//定义一个长度为5的二维数组
int[][] mydata = new int[5][];
//2)给二维数组的元素赋值, 二维数组的每个元素是一个一维数组
//二维数组元素中存储的内容是一维数组的引用
mydata[0] = new int[5];
mydata[1] = new int[]{1,3,5};
int [] data = {2,5,8};
mydata[2] = data;
//mydata[3]和mydata[4]默认初始化为null
//3)遍历二维数组
for(int i = 0 ; i<mydata.length; i++){
//判断mydata[i]这个一维数组是否为null
for( int j = 0 ; mydata[i] != null && j < mydata[i].length; j++){
System.out.print( mydata[i][j] + "\t");
}
System.out.println();
}
//4)在定义二维数组同时,可以指定一维数组的长度,系统会给一维 数组默认初始化
int[][] mydata2 = new int[5][4]; //二维数组的长度是5, 它的元素是一个长度为4的一维数组
//遍历
for (int[] is : mydata2) {
for (int xx : is) {
System.out.print( xx + "\t");
}
System.out.println();
}
//5)mydata2二维数组的每个元素存储的是一维数组的引用
mydata2[0] = data;
mydata2[1] = new int[]{4,5,6,7,8,9};
System.out.println( Arrays.deepToString(mydata2));
//6)二维数组的静态初始化
int[][]mydata3 = new int[][]{ data , new int[5] , new int[]{1,2,3,4} };
System.out.println( Arrays.deepToString(mydata3));
//可以简化为
int[][] mydata4 = {data, new int[5], new int[]{1,2,3,4}};
//还可以写为
int[][] mydata5 = { {1,2,3,4} , {5,6,7} , {8,9}};
System.out.println( Arrays.deepToString(mydata5));
}
}
Java中arrays工具类
static int：
binarySearch(int[] a, int key) 在a数组中查找key元素是否存在,如果存在返回key元素在数组中的索引值,如果不存在返回负数。
static int[]：
copyOf(int[] original, int newLength) 数组的复制, newLength指定新数组的长度, 把orginal数组中的元素复制到新的数组中,返回新的数组。
static int[]：
copyOfRange(int[] original, int from, int to) 把original数组[from,to]范围的元素复制到新的数组中, 返回新的数组。
static String：
deepToString(Object[] a) 把多维数组中的元素转换为字符串。
static void：
fill(int[] a, int val) 使用val值填充整个a数组。
static void：
parallelSort(int[] a) 对数组a进行并行排序, 适合数组元素非常多的情况。
static void：
sort(int[] a) 对数组a进行排序。
static void：
sort(T[] a, Comparator<? super T> c) 对对象数组排序,可以指定对象的比较器。
static String：
toString(int[] a) 把数组的元素转换为字符串。
import java.util.Arrays;
/**
* Arrays工具类的基本使用
*
*
*/
public class Test05 {
public static void main(String[] args) {
int [] data = {67,23,786,4,12,87};
//1)对数组排序
Arrays.sort(data);
//2)打印数组
System.out.println( Arrays.toString(data)); //[4, 12, 23, 67, 87, 786]
//3)数组复制
data = Arrays.copyOf(data, data.length*2 );
System.out.println( Arrays.toString(data )); //[4, 12, 23, 67, 87, 786, 0, 0, 0, 0, 0, 0]
data = Arrays.copyOf(data, data.length*2/3 );
System.out.println( Arrays.toString(data)); //[4, 12, 23, 67, 87, 786, 0, 0]
//4)填充
Arrays.fill(data, 6, data.length, 666);
System.out.println( Arrays.toString(data)); //[4, 12, 23, 67, 87, 786, 666, 666]
//5)二分查找, 前提是数组已经由小到大排序
Arrays.sort(data);
System.out.println( Arrays.toString(data)); //[4, 12, 23, 67, 87, 666, 666, 786]
//只要是返回结果大于等于0,表示元素存在, 结果是负数表示不存在
System.out.println( Arrays.binarySearch(data, 4));
System.out.println( Arrays.binarySearch(data, 67));
System.out.println( Arrays.binarySearch(data, 786));
System.out.println( Arrays.binarySearch(data, 666));
System.out.println( Arrays.binarySearch(data, 888)); //-9
}
}
Java数组算法
Java冒泡排序算法
import java.util.Arrays;
/**
* 冒泡排序,
* 由小到大
* 从前向后两两比较,如果前面的数大于后面的数就交换
* 如果有n个数,需要比较n-1轮
*
*
*/
public class Test06 {
public static void main(String[] args) {
int [] data = {56,23,89,5,99,32};
System.out.println( Arrays.toString(data));
System.out.println("------------------------------");
for( int x = 0 ; x < data.length - 1; x++){
//第x轮, 把第x大的交换到最后
for(int i = 0 ; i < data.length-1 - x ; i++){
if ( data[i] > data[i+1] ) {
int t = data[i];
data[i] = data[i+1];
data[i+1] = t;
}
System.out.println( Arrays.toString(data));
}
System.out.println("------------------------------");
}
}
}
Java选择排序算法
import java.util.Arrays;
/**
* 选择排序
* 由小到大
*
*
*/
public class Test07 {
public static void main(String[] args) {
int [] data = {56,23,89,5,99,32};
System.out.println( Arrays.toString(data));
System.out.println("------------------------------");
for(int x = 0 ; x < data.length-1 ; x++){
//1) 选择最小的,交换到x位置
int min = x ; //保存最小元素的下标,假设x元素最小
//找当前最小元素的下标
for( int i = x+1 ; i< data.length; i++){
if (data[i] < data[min]) {
min = i;
}
}
//把当前最小元素交换到x位置
if ( min != x ) {
int t = data[x] ;
data[x] = data[min];
data[min] = t;
}
System.out.println( Arrays.toString(data));
}
}
}
Java二分查找算法(折半查找算法)
前提是数组已经由小到大排序, 在比较时,始终和中间的元素比较, 如果要查找的数比中间的数小, 说明在左一半; 如果要查找的数比中间的数大, 说明在右一半
● 要查找的元素就 是中间的元素
● 需要多次查找,才能找到元素
● 数组中不存在该元素
/**
* 二分查找算法
*
*
*
*/
public class Test08 {
public static void main(String[] args) {
int [] data = {5, 23, 32, 56, 89, 99};
System.out.println( binarySearch(data, 5));
System.out.println( binarySearch(data, 99));
System.out.println( binarySearch(data, 23));
System.out.println( binarySearch(data, 66));
System.out.println( binarySearch(data, -88));
}
//定义方法, 实现二分查找
//如果myarray数组中存在key元素,返回key元素在数组中的索引值, 如果不存在key元素返回-1
public static int binarySearch(int [] myarray, int key) {
int from = 0 ;
int end = myarray.length-1;
int mid = (from + end) /2;
while( from <= end ){
if ( myarray[mid] == key ) {
return mid;
}else if ( myarray[mid] < key) { //查找的元素比中间的数大, 在右一半
from = mid + 1 ;
mid = (from + end) /2;
}else { //查找的元素比中间的数小, 在左一半
end = mid - 1;
mid = (from + end) /2;
}
}
return -1;
}
}
1107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
