java笔记之数组的概念、声明、初始化、访问方式、复制和动态扩展算法以及递归
前言
数组是存放相同数据类型的顺序结构
正文
数组的概念
一组相同类型的数据堆积在一起
数组的声明
1）数据类型 []数组名；
2）数据类型 数组名[]；（不推荐）
注：数据类型
可以使简单数据类型，也可以使引用数据类型
简单数据类型在内存中的值为零值（boolean：false，int：0，Double：0,0），引用数据类型在内存中的默认值为null。
简单数据类型在内存中存储的是字面量，引用数据类型在内存中存储的第堆区中的地址
3）初始化
1））动态初始化
int[] arr=new int[4]；
int[] arr=new int[]{1,2,3};
注：该语句的执行过程
1.在堆区中开辟4个int类型的空间
2. 将数组元素的赋值为0
3.在栈区中声明数组变量arr，并将变量的值置为null。
5.将堆区中开辟的空间的首地址赋值给栈区的变量arr存储
6.将1,2,3依次放到堆区中对应的位置存储。
2））静态初始化
int[] arr={1,2,3}；//静态初始化只能在声明数组时对其赋值。比如错误例子1：int[] arr；arr={1,2,3}；//错误；错误例子1： arr=new int[4]{1,2,3,4};//错误；不能指定长度
4）数组的访问方式
1））访问数组的元素：
语法：数组名[下标]，下标从零开始
注：
1.数组的长度，数组名.length
2.数组的遍历：将数组的元素一个一个的取出
3.（System.exit(0) 终止JVM的运行，非0的状态码表示异常终止）
5）数组的复制与动态扩展算法
1））数组的赋值
例：int[] arr1=new int[]{1,2,3}；
int[] arr2=arr1；//arr1和arr2指向同一个数组对象，数据对象没有隔离性。
2））两个不同的数组
例：
int[] arr=new int[]{1,2,3}；
int[] arr1=new int[arr.length];//使用原数组的长度定义新数组，复制了空间，赋值内容使用循环遍历
3））Object的clone（）方法
4））工具类 Arrays的API
5））数组拷贝效率更高的2中方式
1）））Static void System.arraycopy(Object[] arc,int srcpost,object[] dest,int destpost,length);
src:原数组，srcpost：原数组拷贝元素的起始位置，dest：目标数组，destpost:将原数组的元素拷贝到目标数组的第几个位置；length：将原数组的多少个元素拷贝到目标数组；
注：
该方法由java的Api提供，底层由c++实现的，效率高，比for循环遍历拷贝的效率高
2）））Arrays.copyof(original,newLength)
src:原数组，newLength:新数组的长度
例：自拷贝（空间）扩容
String[] str=new String[]{"a","b","c"};
str=Arrays.copyof(str,str.length+1);//[a,b,c,null]
注：此时的str与原str的引用地址不一样，但堆区中里面的元素的地址仍指向同一对象，属于浅拷贝。在java中只有I/O属于深拷贝
排序
1）概念：让数据有序的存储
2）分类：八大排序（选择，快速，冒泡，插入，归并和堆）
1））选择排序
1）））原理：固定一个位置，与其他位置作比较，满足条件交换位置
使用i表示第一个数据：0~arr.length-2
使用j表示后面部分的数据：i+1~arr.length-1;(j<arr.length,j++;i>j交换)
2））冒泡：
1）））原理：总是，相邻的两个位置作比较，如果满足条件，交换位置
注：
i表示次数，0~arr.lenth-2
j表示比较的位置，0~arr.lenght-i-1
j=1 j<arr.length-i j++
if j-1>j 交换
3))插入：
1）））原理：将数组分成两段，一段放大的数据，一段放小的数据
注：
j代表需要插入的元素的位置，1~arr.lenght-1
i代表前一部分每一个元素的位置 0~j-1
示例：
for(int j=1;j<arr.length;j++){
int temp=arr[j];
int i=j-1;
for(;i>=0;i--){
if(arr[i]>temp){
arr[i+1]=arr[i];
}else{
break;
}
}
arr[i+1]=temp;
}
递归
1)本质：自己调用自己
2）递归是一种算法，基本思想：对于一个复杂的问题，将原问题分解为若干个相对简单的子问题，继续下去直到简单的问题能够解决求解，也就是找到问题的出口。
3）关键因素：
递归的出口
递归逐步的向出口推进
4）递归的应用场景：
当一次运算无法计算出结果，而且是自己调用自己，只有找到出口才拿到结果。然后返回来进行下一步的运算。
5）递归的特点：
递归的时候，按照递归的深度分配全部的临时变量，栈开销很大，性能较低，要注意不能超越栈空间的大小。并且要给出一定的结束条件，否则，会造成栈溢出。
6）阶乘的例子
public class Recursion{
public static void main(String[] args){
recursion(100);
}
public int recursion(int n){
if(n=1){
return ;
}
return n*recursion(n-1);
}
}
总结
java数组如何实现逆序存放
public class ReverseArray{
public static void reverseArray(int[] a){
int i=0;
int n=a.length-1;
while(n>2*i){
int x=a[i];
a[i]=a[n-i];
a[n-i]=x;
i++;
}
}
}
找出二维数组的鞍点（行的最大值，当前行所在的列的最小值）
public class Saddle{
public void saddlePoint(int[][] array){
int rows=array.length;//行数
int cols=array [0].length ;//列数
int i;
int j;
int k;
int maxofrow;//行的最大值
int colofmax;//最大值所在的列
for(i=0;i
array[k][colofmax]){//不是所在的类的最小值
break;//继续下一行的遍历查找
}
if(k==rows) System.out.println("Saddle Point"+"at"+"i,"+"colofmax");//如果比较完最大值所在的列，就表明找到了鞍点。否则早就break了
}
}
}
}
数组实现栈的功能
public Class StackDemo{
private int top=-1;//栈顶的位置
private Object[] ss=new int[10];
public StackDemo(){
}
public StackDemo(int n){
ss=new Object[n];
}
public static void main(String[] args){
StackDemo stack=new StackDemo(11);
stack.pust(ss,1);
stack.push(ss,2);
while(!stack.stackIsEmpty()){
int p=stack.pop(ss);
System.out.pritnln(p);
}
}
private boolean stackIsEmpty(){
if(top==-1){//空栈
return true;
}else{
return false;
}
}
private void push(Object o ){
top=top+1;//栈顶指针上移
s[top]=o;//入栈
}
private Object pop(){
if(stackIsEmpty()){
return null;//空栈
}else{
return ss[top--];//栈顶指针下移
}
}
}
}
文章来源: kunnan.blog.csdn.net，作者：iOS逆向，版权归原作者所有，如需转载，请联系作者。
原文链接：kunnan.blog.csdn.net/article/details/22175521
- 点赞
- 收藏
- 关注作者
评论（0）