------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
数组
概述：相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。
特点
-
1.数组是相同数据类型的元素的集合。
-
2.数组中的各元素是有先后顺序的，它们在内存中按照这个先后顺序连续存放在一起。
-
3.数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如，a[0]表示名字为a的数组中的第一个元素，a[1]代表数组a的第二个元素，以此类推。
数组定义
1.静态定义：定义的数组能有合适的长度 格式：格式：元素类型[] 数组名={元素,元素,元素}。
2.动态定义：定义数组时不能指定其长度（数组中元素的个数），Java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素的个数]。
数组初始化
-
1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行。
-
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值。
-
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。
常见的数组操作方法
1.取最小值、最大值
package Array;
public class ArrayMaxMin
{
public static int min(int[] arr) //取数组中的最小值。
{
int min = 0; //定义接受最小值的变量。
for(int i=0; i<arr.length; i++) //遍历数组，遍历到的位置上的元素如果比min小就把值赋给min。
{
if(min>arr[i])
min=arr[i];
}
return min; //遍历结束返回最小值。
}
public static int max(int[] arr) //取数组中的最大值。
{
int max = 0; //定义接受最大值的变量。
for (int i = 0; i < arr.length; i++) //遍历数组，遍历到的位置上的元素如果比max大就把值赋给max。
{
if(max<arr[i])
max = arr[i];
}
return max; //遍历结束返回最大值。
}
public static void main(String[] args)
{
int[] arr = {-1,2,4,-3,-5,10};
System.out.println(max(arr));
System.out.println(min(arr));
}
}2.对数组进行排序
package Array;
public class ArraySort
{
public static int[] sort_1(int[] arr) //选择排序，首先把下标1位置的元素与依次与其他位相比，如果小于下标1位置上的元素就把两个位置的元素换。
{
for(int i=0; i<arr.length-1; i++) //每次循环依次就把i位置上的数确定好了。
{
for (int j = i+1; j < arr.length; j++)
{
if(arr[i]>arr[j])
{
swap(arr, j, i); //交换两个位置上的元素。
}
}
}
return arr;
}
public static int[] sort_2(int[] arr) //冒泡排序是把相邻的两个元素进行比较，如果前者大于后者就互换位置。
{
for(int i=0; i<arr.length-1; i++)
{
for(int j=0; j<arr.length-i-1; j++)
{
if(arr[j]>arr[j+1])
{
swap(arr, j, j+1); //交换两个位置上的元素。
}
}
}
return arr;
}
public static void swap(int[] arr, int a, int b) //交换元素。
{
int tem = arr[a];
arr[a] = arr[b];
arr[b] = tem;
}
public static void sop(int[] arr) //打印排序后的数组。
{
System.out.print("{");
for (int i = 0; i < arr.length; i++)
{
if(i==arr.length-1)
System.out.println("}");
else
System.out.print(arr[i]+",");
}
}
public static void main(String[] args)
{
int[] arr = {-1,3,-4,10,5,-6,9};
sop(sort_1(arr));
sop(sort_2(arr));
}
}3.修改数组元素
package Array;
public class ArratModify
{
public static int halfSearch(int[] arr, int key) //利用折半查找找到元素要插入的位置
{
int min = 0;
int max = arr.length-1;
int mid;
while(min<=max) //如果最小值大于最大值结束循环。
{
mid = (min+max)>>1; //折半运算
if(key>arr[mid]) //如果折半位置上的数小于插入值，min就等于mid+1。
min = mid +1;
else if(key==mid) //如果折半位置上的数等于插入值，就返回mid。
return mid;
else //如果折半位置上的数大于插入值，max就等于mid-1。
max = mid-1;
}
return min;
}
public static int[] addelement(int[] arr, int value) //添加元素，指定添加到末尾 数组：arr、插入值：value。
{
int[] arrs = new int[arr.length+1]; //创建一个新的数字，是来接收原来数组和插入值新组成的数组，所以长度比原来数组长1.
for (int i = 0; i < arrs.length; i++)
{
if(i==arrs.length-1) //新数组最后的值为插入值。
arrs[arrs.length-1] = value;
else
arrs[i] = arr[i];
}
return arrs;
}
public static int[] addelement(int[] arr, int pos, int value) //添加元素到数组的指定位置 数组：arr、插入位置：pos、插入值：value。
{
if(pos==arr.length) //插入位置为数组最后一位，就直接调用第一个添加元素方法。
return addelement(arr, value);
else if(pos>arr.length) //插入位置在数组不存在，就插入失败返回原数组。
{
System.out.println("插入失败：插入的位置不存在！");
return arr;
}
else //插入位置在数组存在并不是最后一位。
{
int[] arrs = new int[arr.length+1]; //定义新的数组用来接收插入值和原来数组新组成的数组。
for (int i = 0; i < arr.length; i++) //循环遍历原来数组。
{
if(i<pos) //遍历位置小于插入位置，就按原来的顺序在新的数组加入原数组的通顺序的元素。
arrs[i] = arr[i];
else if(i==pos) //遍历位置等于插入位置，把插入值放入遍历位置,并把原数组的遍历位置上的值放到新数组的遍历位置+1上。
{
arrs[i+1] = arr[i];
arrs[i] = value;
}
else //遍历位置大于插入，把原数组的遍历位置上的值放到新数组的遍历位置+1上。
arrs[i+1] = arr[i];
}
return arrs;
}
}
public static int[] addelement(int[] arr, int value,boolean isOrder) //添加元素到有序数组中，添加后，保证数组还是有序，数组：arr、插入值：value、是否有序：isOrder。
{
if(isOrder==false)
return addelement(arr, value); //无序的话就直接调用添加元素到到末尾。
else
return addelement(arr, halfSearch(arr, value),value); //有序的，就先调用halfSearch找到插入位置，把这个插入位置当参数传入addelement(int[] arr, int pos, int value)即可。
}
public static void sop(int[] arr)
{
System.out.print("{");
for(int i=0;i<arr.length;i++)
{
if(i==arr.length-1)
System.out.println(arr[i]+"}");
else
System.out.print(arr[i]+",");
}
}
public static int[] modifyelement(int[] arr, int pos, int value) //修改指定位置的元素，如果指定位置不存在修改失败，数组：arr、修改位置：pos、修改值：value。
{
if(0<=pos&&pos<arr.length)
{
arr[pos] = value; //把指定的上的值改为修改值。
return arr;
}
System.out.println("修改失败：修改元素位置不存在！");
return arr;
}
public static int[] deleteelement(int[] arr) //删除全部元素。
{
return arr = null;
}
public static int[] deleteelement(int[] arr, int pos) //删除指定位置上的元素，数组：arr、删除位置：pos。
{
if(pos<0 || pos>arr.length-1) //删除位置不是在0~数组下标最大值之间，就删除失败。
{
System.out.println("删除失败：删除位置在数组中不存在！");
return arr;
}
else
{
int[] arrs = new int[arr.length-1]; //定义新的数组接受删除了一个元素的原数组。
for (int i = 0; i < arrs.length; i++)
{
if(i<pos)
arrs[i] = arr[i]; //当遍历位置小于删除位置，新的数组按原数组顺序添加元素。
else
arrs[i] = arr[i+1]; //当遍历位置大于或等于删除位置，把删除位置后面的数放到新的数组中。
}
return arrs;
}
}
public static int[] deleteelement(int value, int[] arr) //删除数组中的指定元素，数组：arr、指定值：value。
{
if(select(value, arr)==true) //判断数组中有没有此值，没有就删除失败。
{
return deleteelement(arr, select(arr, value)); //用select方法返回指定元素的位置，然后用删除指定位置元素的方法删除元素。
}
else
{
System.out.println("删除失败：删除元素在数组中不存在！");
return arr;
}
}
public static int select(int[] arr, int key) //得到指定数在数组中的位置的函数。
{
for(int i=0; i<arr.length; i++)
{
if(arr[i]==key)
return i; //数组中有此元素就返回此元素的位置。
}
return -1; //数组中没有此元素就返回-1.
}
public static Boolean select(int key, int[] arr) //重载select方法判断指定数是否在数组中存在的函数。
{
if(select(arr, key)>=0) //调用select（int[] arr,int key）,返回-1就代表数组中没有此元素，返回大于或等于0的数就表示数组有此元素。
return true; //select（int[] arr,int key返回大于或等于0的数此函数就返回true，返回-1就返回false。
return false;
}
public static void main(String[] args)
{
int[] arr = {1,2,3,4};
sop(addelement(arr,9));
sop(addelement(arr,1,9));
sop(addelement(arr, 4, true));
sop(modifyelement(arr,3,3));
sop(deleteelement(arr, 2));
sop(deleteelement(1, arr));
}
}4.比较数组元素大小
package Array;
public class ArrayEquals
{
public static int equals(int[] arr, int pos, int key) //比较一个数与数组中指定位置元素的大小，pos：指定数组中的元素位置，key：比较数。
{
if(arr[pos]>key)
return 1; //如果数组中指定位置的元素大于比较数，就返回1.
else if(arr[pos]==key)
return 0; //如果数组中指定位置的元素等于比较数，就返回0。
else
return -1; //如果数组中指定位置的元素小于比较数，就返回-1.
}
public static void main(String[] args)
{
int[] arr = {-1,-4,7,9,-2,10};
System.out.println(equals(arr, 3, 10));
}
}</span>
5.十进制转其他进制
<span style="font-size:14px;">package Array;
public class ArrayHex
{
public static void trans(int value, int hex, int offest)
{
char[] ch = {'0','1','2','3','4','5','6','7'
,'8','9','A','B','C','D','E','F'}; //建立进制表，包含了2进制、8进制、16进制的所有进制数。
char[] arr = new char[32]; //最长的2进制就是32位，定义一个32的字符数组。
int temp = arr.length;
while(value!=0) //只要值不为0就做value&hex运算。
{
int i = value & hex;
arr[--temp]= ch[i]; //把i对应的进制表的值赋给字符数组。
value = value>>>offest; //每循环一次就向右偏移offest位。
}
for( int i=temp;i<arr.length; i++) //循环跳出的时候tem前面的数全为0，从tem开始编译字符数组可以去掉前面的0。
{
System.out.print(arr[i]);
}
}
public static void toBiny(int value)
{
trans(value, 1, 1); //2进制是value & 1运算，每次循环向右偏移1位。
System.out.println();
}
public static void toEight(int value)
{
trans(value, 7, 3); //8进制是value & 7运算，每次循环向右偏移3位。
System.out.println();
}
public static void toHex(int value)
{
trans(value, 15, 4); //16进制是value & 15运算，每次循环向右偏移4位。
System.out.println();
}
public static void sop(int[] arr)
{
for (int i = 0; i < arr.length; i++)
{
System.out.print(arr[i]);
}
}
public static void main(String[] args)
{
toBiny(60);
toEight(60);
toHex(60);
}
}
413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
