JavaSE笔记5-数组
一. 定义
1. 概念
同一种类型数据的集合，数组就是一个容器
2. 好处
可以自动给数组中的元素从0开始编号，方便操作元素
3. 格式
//格式1
//元素类型 [] 数组名=new 元素类型[元素个数或数组长度];
int [] arr=new int [5];
//格式2：静态初始化，不能写出元素个数/数组长度
//元素类型 [] 数组名=new 元素类型 []{元素,元素,...};
int [] arr=new int []{1,2,3,4};
4. 注意
int [] arr=new int [5];
其中，arr的数据类型为数组，不是int，属于引用类型；
数组arr中每个元素的数据类型为int
5. 内存结构
Java程序在运行时，需要在内存中分配空间。
为了提高运算效率，对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
（1）栈内存
用于存储局部变量，当数据使用完，所占空间会自动释放
（2）堆内存
用户存储数组和对象
通过new建立的实例都存放在堆内存中，每一个实体都有内存地址值
int [] x=new int[3]; //将数组在内存中的地址赋给数组x（引用类型，引用的是地址）；
x[0]=59; //实体中的变量都有默认初始化值（int类型默认初始化值为0）
实体不再被使用，会在不确定的时间内被垃圾回收器回收
x=null；//x引用没有指向实体
二. 常见操作
1. 遍历
获取数组元素的个数：数组名称.length
class ArrayDemo
{
public static void main(String[] args)
{
int [] arr1=new int [3];
arr1[0]=1;
arr1[1]=2;
arr1[2]=3;
int [] arr2=new int []{4,5,6,7,8};
int [] arr3=new int [3];
printArray(arr1);
printArray(arr2);
System.out.println(arr3);
}
//定义功能，用于打印数组中的元素，元素间用逗号隔开
public static void printArray(int [] arr)
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
}
2. 获取最值
获取最大值
class ArrayDemo
{
public static void main(String[] args)
{
int [] arr={5,1,6,5,2,8,9};
int max=getMax(arr);
int max_2=getMax_2(arr);
System.out.println("max="+max);
System.out.println("max="+max_2);
}
public static int getMax(int [] arr)
{
int max=arr[0];
for(int i=1;i<arr.length;i++)
{
if(arr[i]>max)
max=arr[i];
}
return max;
}
public static int getMax_2(int [] arr)
{
int max=0;
for(int i=1;i<arr.length;i++)
{
if(arr[i]>arr[max])
max=i;
}
return arr[max];
}
}
获取最小值
class ArrayDemo
{
public static void main(String[] args)
{
int [] arr={5,1,6,5,2,8,9};
int min=getMin(arr);
int min_2=getMin_2(arr);
System.out.println("min="+min);
System.out.println("min="+min_2);
}
public static int getMin(int [] arr)
{
int min=arr[0];
for(int i=1;i<arr.length;i++)
{
if(arr[i]<min)
min=arr[i];
}
return min;
}
public static int getMin_2(int [] arr)
{
int min=0;
for(int i=1;i<arr.length;i++)
{
if(arr[i]<arr[min])
min=i;
}
return arr[min];
}
}
3. 排序（选择排序、冒泡排序）
（1）选择排序
内循环一次，最值出现在头角标位置上
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[x]>arr[y])
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
（2）冒泡排序
相邻的两个元素进行比较，如果符合条件换位。
内循环一次，最值出现在尾角标位置上
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;
}
}
}
}
（3）Java中自定义的排序函数
import java.util.*;
class ArrayDemo
{
public static void main(String[] args)
{
int [] arr={5,1,6,4,2,8,9};
printArray(arr);
Arrays.sort(arr);
printArray(arr);
}
public static void printArray(int [] arr)
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
}
（4）位置置换功能
public static void swap(int [] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
4. 折半查找（二分查找）
（1）普通查找
class ArrayDemo
{
public static void main(String[] args)
{
int [] arr={3,2,1,5,4,2,9};
int index=getIndex(arr,2);
System.out.println("index="+index);
}
//定义功能，获取key第一次出现在数组中的位置；如果返回值为-1，代表该key在数组中不存在
public static int getIndex(int [] arr,int key)
{
for(int i=0;i<arr.length;i++)
{
if(arr[i]==key)
return i;
}
return -1;
}
}
（2）折半查找
要保证查找的数组有序
//折半查找1
public static int halfSearch(int [] arr,int key)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if(min>max)
return -1;
mid=(min+max)/2;
}
return mid;
}
//折半查找2
public static int halfSearch_2(int [] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(min+max)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
（3）Java中自定义的折半查找
import java.util.*;
class ArrayDemo
{
public static void main(String[] args)
{
int [] arr={2,4,5,7,8,19,32,45};
int index=Arrays.binarySearch(arr,8);
System.out.println("index="+index);
}
}
三. 进制转换
1. 十进制–>二进制
class ArrayDemo
{
public static void main(String [] args)
{
toBin(6);
}
public static void toBin(int num)
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}
}
2. 十进制–>十六进制
class ArrayDemo
{
public static void main(String[] args)
{
toHex(60);
}
//十进制-->十六进制
public static void toHex(int num)
{
StringBuffer sb=new StringBuffer();
for(int i=0;i<8;i++)
{
int temp=num&15;
if(temp>9)
sb.append((char)(temp-10+'A'));
else
sb.append(temp);
num=num>>4;
}
System.out.println(sb.reverse());
}
}
3. 查表法
class ArrayDemo
{
public static void main(String[] args)
{
toBin(6);
toBin(-6);
toOct(60);
toOct(-60);
toHex(60);
toHex(-60);
}
//十进制-->二进制
public static void toBin(int num)
{
trans(num,1,1);
}
//十进制-->八进制
public static void toOct(int num)
{
trans(num,7,3);
}
//十进制-->十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//进制转换函数，其中base为与的位数，offset为右移的位数
public static void trans(int num,int base,int offset)
{
//如果十进制数为0，直接打印0
if(num==0)
{
System.out.println(0);
return;
}
//查表
char [] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义临时变量存储转换后的值
char [] arr=new char[32];
//定义指针
int pos=arr.length;
while(num!=0)
{
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
}
四. 二维数组
1. 定义
int [][]arr=new int [3][4];//定义了名称为arr的二维数组，二维数组中有3个一维数组
//每个一维数组中有4个元素
class Array2Demo
{
public static void main(String[] args)
{
int [][]arr1=new int [3][4];
System.out.println(arr1); //打印结果为：[[I@5451c3a8
System.out.println(arr1[0]); //打印结果为：[I@2626b418
System.out.println(arr1[0][1]); //打印结果为：0
int [][]arr2=new int [3][];
System.out.println(arr2); //打印结果为：[[I@5a07e868
System.out.println(arr2[0]); //打印结果为：null
int [][]arr=new int [3][];
arr[0]=new int[3];
arr[1]=new int[1];
arr[2]=new int[2];
System.out.println(arr[0]); //打印结果为：[I@76ed5528
}
}
class Array2Demo
{
public static void main(String[] args)
{
int [][]arr=new int [3][];
arr[0]=new int[3];
arr[1]=new int[1];
arr[2]=new int[2];
System.out.println(arr.length);//打印的是二维数组的长度 3
System.out.println(arr[0].length);//打印的是二维数组中第1个一维数组的长度
}
}
2. 一维数组&二维数组的定义辨析
一维数组
int [] x;//第一种
int x [];//第二种
二维数组
int [][]y;//第一种
int y[][];//第二种
int []y[];//第三种
辨析
int []x,y[];//其中x为一维数组，y为二维数组
//int []x;
//int []y[];
五. Arrays类
1. 概述
- Arrays类时Java提供的一个操作数组的工具类
- Arrays类提供了许多操作数组的静态方法，借助这些静态方法可以实现对数组元素的排序、查找替换、转换成字符串或集合等操作
- Arrays类中的方法都是静态的
- Arrays类中没有构造函数，不能进行实例化
2. 常用方法
（1）数组转字符串
/*
该方法将一个数组转换成一个字符串：
按顺序把多个数组元素连缀在一起，括在方括号中，多个数组元素使用英文逗号和空格隔开
*/
static String toString(type[] a);
例子：
import java.util.*;
class ArraysDemo{
public static void main(String[] args) {
int[] arr={2,4,5};
System.out.println(arr);
System.out.println(Arrays.toString(arr));
}
}
运行结果是：
（2）数组转List集合
//返回由指定数组支持的固定大小的列表
static <T> List<T> asList(T...a);
把数组变成List集合有什么好处：
可以使用集合的思想和方法来操作数组中的元素，例如可方便使用List集合的contains方法判断List集合中是否存在某元素
注意：
将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的；
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素；
如果数组中的元素都是基本数据类型，那么变成集合时，会将该数组作为集合中的元素
例子：
import java.util.*;
class ArraysDemo{
public static void main(String[] args) {
//数组中的元素是基本数据类型int
int[] nums={2,4,5};
List li=Arrays.asList(nums);
System.out.println(li);
//将该数组作为集合中的元素
List<int[]> li1=Arrays.asList(nums);
System.out.println(li1);
//装入Integer类对象
Integer[] nums1={2,4,5};
List<Integer> li2=Arrays.asList(nums1);
System.out.println(li2);
String[] arr={"abc","cc","kkkk"};
//把数组变成list集合
List<String> list=Arrays.asList(arr);
System.out.println(list);
System.out.println("contains: "+list.contains("cc"));
//不可以对由数组转成的List集合进行增删操作
list.add("qq");
}
}
运行结果是：
（3）集合转数组
Collection接口中的toArray方法
//返回包含此Collection中所有元素的数组
Object[] toArray();
//返回包含此Collection中所有元素的数组，返回数组的运行时类型与指定数组的运行时类型相同
<T> T[] toArray(T[] a);
指定类型的数组到底要定义多长呢：
当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size；
当指定类型的数组长度大于集合的size，就不会新创建数组，而是使用传递进来的数组；
所以创建一个长度等于集合size的数组是最优的。
import java.util.*;
class CollectionToArray{
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
//指定类型的数组长度为0
String[] arr1=al.toArray(new String[0]);
System.out.println(Arrays.toString(arr1));
//指定类型的数组长度为5
String[] arr2=al.toArray(new String[5]);
System.out.println(Arrays.toString(arr2));
}
}
运行结果是：
