//建议通过目录查找需要的内容
一：知识点：
1.遍历数组的方法
1.简单的遍历
1）for循环
for(int i = 0 ;i <length；i++){}
这是通过数组下标来进行数组定位，进而输出数组数值的，使用的情况较多
注意：边界，即i的范围，不能超出数组的数值范围，
2)for each循环
直接迭代数组的每个元素，在for(int n : ns)循环中，n直接拿到ns数组的元素，而不是通过索引，所以：for each的循环更加简洁，缺点是不能直接拿到下标为n的数组元素。
public class Main {
public static void main(String[] args) {
int[] ns = {1,3,5,6,78};
for(int n : ns){
System.out.println(n);
}
}
}2.打印数组内容
1.直接打印数组名，结果是数组在JVM中的引用地址
public class Main {
public static void main(String[] args) {
int[] ns = {1,3,5,6,78};
int[] num={234,456,36,54};
System.out.println(ns); //[I@4eec7777
System.out.println(num); //[I@3b07d329
}
}2.无特殊要求，使用Arrays.toString()
public class Main {
public static void main(String[] args) {
int[] ns = {1,3,5,6,78};
int[] num={234,456,36,54};
System.out.println(Arrays.toString(ns)); //[1, 3, 5, 6, 78]
System.out.println(Arrays.toString(num)); //[234, 456, 36, 54]
}
}3.二维数组
定义方式：
public class Main {
public static void main(String[] args) {
int[][] ns1=new int[3][5]; //3个长度为5的二维数组，默认值为0
int[] ns2[]=new int[3][4]; //3个长度为4的二维数组，默认值为0
int[][] ns3=new int[4][]; //4个为null的数组
}
}输出方式（for/for each/Arrays.deepToString）
public class Main {
public static void main(String[] args) {
int[][] ns = {
{1,3,6},
{343,67,3},
{235,65,2}
};
for(int []arr:ns){
for(int n : arr){
System.out.print(n);
System.out.print(',');
}
}
//结果：1,3,6,343,67,3,235,65,2,
//System.out.println(Arrays.deepToString(ns));
//结果：[[1, 3, 6], [343, 67, 3], [235, 65, 2]]
}
}2.数组排序
冒泡排序
原理：
每次比较相邻两个元素，如果第一个比第二个大，就交换，并且i++,一个周期后最后一个就是最大的数据，然后再重复N-1次，每次周期比较N-1-i次,
public class Main {
public static void main(String[] args) {
int[] ns={3,56,54,7,76,4,8,9,23};
for(int i=0;i<ns.length-1;i++){
for(int k=0;k<ns.length-1-i;k++){
if(ns[k]>ns[k+1]){
int tmp = ns[k];
ns[k]=ns[k+1];
ns[k+1]=tmp;
}
}
}
System.out.println(Arrays.toString(ns));
}
}插入排序
快速排序
使用Arrays工具类排序
java标准库中已经内置了排序功能，我们只用调用Arrays.sort()即可
public class Main {
public static void main(String[] args) {
int[] ns={3,56,54,7,76,4,8,9,23};
Arrays.sort(ns);
System.out.println(Arrays.toString(ns));
}
}3.查找元素
1.无序数组查找指定元素
1）直接遍历整个数组
1.整形数组
public class Main {
public static void main(String[] args) {
int[] ns={3,56,54,7,76,4,8,9,23};
int target = 54;
int index=-1;
for(int i=0;i<ns.length;i++){
if(ns[i]==target){
index=i;
break;
}
}
System.out.printf("目标数为d%,下表为d%",target,index);
}
}注意是printf，如果找到目标数，则break，不用继续循环。
2.字符串数组
public class Main {
public static void main(String[] args) {
String[] ns={"万","李荣启","尼伯龙根","楚子航","路明泽","诺诺"};
Scanner input = new Scanner(System.in);
String target = "楚子航";
int index=-1;
for(int i=0;i<ns.length;i++){
if(target.equals(ns[i])){
index=i;
break;
}
}
System.out.printf("目标"+target+",下标为"+index);
}
}注意：这里是字符串，而字符串之间进行比较要使用equals（）进行比较，因为java中字符串是引用类型，所指向的是他的内存地址，用“==”比较的是字符串的内存地址，用equals()比较的是字符串的ASCLL码，ASCLL码一样，两个字符串自然一样。
2）双指针遍历
1.整形数组
通过两个下标，分别从素组头部和尾部对该序列进行遍历，将数组中的元素和指定元素进行比较，从而确定数组中是否有该元素。
public class Main {
public static void main(String[] args) {
int [] array={23,5,356,65,76,3,65,54,4,36};
int target = 3;
int index = -1;
for(int i=0,k=array.length-1;i<k;i++,k--){
if(array[i]==target){
index = i;
break;
}
if(array[k]==target){
index = k;
break;
}
}
System.out.printf("目标数%d在数组的下标为：%d",target,index);
}
}字符串数组
public class Main {
public static void main(String[] args) {
String [] array={"哈哈","虚无","星河猎手","胡桃","托帕","芙宁娜","那维莱特"};
String target = "托帕";
int index = -1;
for(int i=0,k=array.length-1;i<=k;i++,k--){
if(target.equals(array[i])){
index = i;
break;
}
if(target.equals(array[k])){
index = k;
break;
}
}
System.out.printf("目标数%s在数组的下标为：%d",target,index);
}
}Arrays工具类的binarySearch()方法
该方法基于二分查找实现，所以在使用前必须先排序
public class Main {
public static void main(String[] args) {
int [] array={23,5,356,65,76,3,65,54,4,36};
int target = 76;
Arrays.sort(array); //排序
int index = Arrays.binarySearch(array,target);
System.out.printf("下标为%d",index);
}
}二分查找元素
在一个有序的集合中，每次拿中间的值和target进行比较，如果中间的值大于target,说明所求的值在中间值的左边，反之则在右边，这样一次就可以筛选出一半的值，极大的缩减所需要花费的时间。
具体的实现如下：
public class Main {
public static void main(String[] args) {
int [] array={23,5,356,65,76,3,65,54,4,36}; //数组
int target = 76;
int index = -1; //找到下标返回,没找到返回-1
Arrays.sort(array);
int low = 0,high = array.length-1; //定义最小边界和最大边界
while(low<high){ //当最小边界的下标小于最大边界的下标才成立，否则说明数组遍历完了
int mid = (low+high)/2; //取中间值
if(array[mid]==target){ //如果中间值就是所要找的数，赋值下标并返回
index = mid;
break;
}else if(array[mid]>target){ //如果中间值大于要找的数，则要找的数在中间值的左边
high = mid-1; //因为中间值本身也不是要找的数，所以-1
}else if(array[mid]<target){ //同上，在右边
low = mid+1;
}
}
System.out.printf("下标为%d",index);
}
}4.数组乱序（数组洗牌）
题目简介：
有一个大小为100的数组，里面的元素是从1到100，随机从数组中选择50个不重复的数（即产生50个不重复的1-100之间的数字）
实现：
public class Main {
public static void main(String[] args) {
int [] array={23,5,356,65,76,3,65,54,4,36};
for(int i=array.length-1;i>0;i--){
int index = (int)(Math.random()*i); //随机产生一个i之前的数的下标
int target = array[index]; //下面3行是
array[index] = array[i];
array[i] = target;
}
System.out.println(Arrays.toString(array));
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
