Array/ArrarList 常用方法

发表于 |

Array / ArrayList 基本使用

注意程序运行时堆,栈,方法区的变化: 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
* Java的内存划分为5个部分:
* 1.栈(Stack):存放的都是方法中的局部变量
*           局部变量：方法的参数或者是方法{}中的变量
*           作用域: 一旦超出作用域，立刻从栈中消失
* 2.堆(Heap):凡是new出的东西都在堆当中
*           堆内存中的东西都有一个地址值：16进制
*           堆内存中的数据默认都有值。规则：
*               整数      默认：0
*               浮点数    默认：0.0
*               字符      默认：'\u0000'
*               布尔      默认：false
*               引用类型    默认：null
*
* 3.方法区(Method Area): 存储class相关信息。包含方法的信息
* 4.本地方法栈(Native Method Stack):与操作系统相关
* 5.寄存器(pc Register): 与cpu相关

补充：

1
2
3
4
5
java四类八种基本数据类型 度量单位均为字节
第一类：整型 byte 1  short 2 int4 long8
第二类：浮点型 float4 double8
第三类：逻辑型 boolean(它只有两个值可取true false) 1/8字节
第四类：字符型 char

Array基本用法

数组是一组容器，用来存放多个数据值
特点：

1.数组是一种引用数据类型

2.数组中的多个数据类型类型必须统一

3.数组的长度在程序运行期间不能改变

两种初始化方式：
1）动态初始化 数据类型[] 数组名称=new 数据类型[组数长度]
2）静态初始化 数据类型 数组名称=new 数据类型{元素1,元素2,….};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
//定义声明
String[] str=new String[5];
int[] array=new int[]{5,15,35,6,78,66};
byte[] bytes={'1','5','6'};

//获取最大值
public int  getMax(int[] arr){
 	int max=0;
	for(int i=1; i<arr.length;i++){
	if(arr[i]>arr[max]){
	max=i;
	}
	}
       	return arr[max];
  }

//获取最小值
public int  getMin(int[] arr){
 	int min=0;
	for(int i=1; i<arr.length;i++){
	if(arr[i]<arr[min]){
	min=i;
	}
	}
       	return arr[min];
}

//排序
public void selectBort(int[] arr){
 	for(int x=0;x<arr.length;x++){
 	 	for(int y=x+1;y<arr.length;y++){
          if(arr[x]>arr[y]){
			swap(arr,x,y);
		   }
		}
	}
  }

public void swap(int[] arr,int a,int b){
	int temp=arr[a];
	arr[a]=arr[b];
	arr[b]=temp;
}

/**
 * 稀疏数组
 */
int[][] arr=new int[10][10];
arr[2][3]=10;
arr[5][7]=35;
arr[6][2]=12;
 //输出稀疏数组
System.out.println("输出原始数组:");
for (int[] i:arr) {
   for (int j:i) {
      System.out.printf(j+"\t");
   }
      System.out.println("");
 }

 //压缩为稀疏数组
int sum=0;
for (int i = 0; i <arr.length ; i++) {
   for (int j = 0; j <10 ; j++) {
       if (arr[i][j]!=0){
             sum=sum+1;
        }
   }
}
System.out.println("共有"+sum+"个有效值.");
//进行数组压缩
int [][] arr2=new int[sum+1][3];
arr2[0][0]=10;
arr2[0][1]=10;
arr2[0][2]=sum;
int count=0;
for (int i = 0; i <arr.length ; i++) {
  for (int j = 0; j<arr[i].length ; j++) {
      if (arr[i][j]!=0){
         arr2[count+1][0]=i;
         arr2[count+1][1]=j;
         arr2[count+1][2]=arr[i][j];
         count++;
       }
  }
}
 System.out.println("输出稀疏数组:");
 for (int i = 0; i <arr2.length ; i++) {
    System.out.println(Arrays.toString(arr2[i]));
 }
 //将稀疏数组转化为数组输出
 System.out.println("将稀疏数组转化为数组:");
 int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
 for (int i = 1; i <arr2.length ; i++) {
     arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
 }
 for (int i = 0; i <arr3.length ; i++) {
    for (int j = 0; j <arr3[i].length ; j++) {
      System.out.print(arr3[i][j]+"\t");
    }
      System.out.println(" ");
  }

Scanner 键盘输入

注意next与nextLine
next方法不能包含空格，遇见空格认为结束。会一直等待用户输入字符，自动去掉用户输入字符之前的空格
nextLine方法以enter作为结束标志，可以获得空格

1
2
3
Scanner scanner=new Scanner(System.in);
System.out.printf(scanner.next());
scanner.close();

ArrayList基本用法

1.数字长度可以任意变化
2.代表泛型，泛型也就是装在集合中的所有元素，全部都是统一的某种类型
注意：泛型只能是引用类型不能是基本类型
3.对于ArrayList来说直接打印的得到的不是地址值而是内容，如果内容为空则打印[]
4.ArrayList 底层是数据存储结构是数组，元素增删慢，查询快；

1
2
3
4
ArrayList<String> arrayList=new ArrayList();
System.out.print(arrayList);
arrayList.add("hello world");
System.out.print(arrayList);

常用方法：

1.public boolean add ;向集合中添加元素，参数类型和泛型保持一致
备注：对于array List元素来说，add添加元素是一定成功的，返回值可以不用， 其他集合的的add添加动作不一定成功.
2.public E get(int index) ;从集合中获取元素，参数是索引编号，返回值就是对应位置的元素
3.public E remove(int index) ; 从集合中删除元素，参数是索引编号，返回值就是被删除掉的元素
4.public int size() ; 获取集合尺寸长度，返回值是集合中包含的元素个数

1
2
3
4
5
6
7
8
9
10
11
12
boolean success=arrayList.add("I am student");
System.out.print("添加的动作是否成功"+success);
//从集合中获取元素：get.索引值从0开始.
String string=arrayList.get(0);
System.out.printf("从集合中获取的元素是:"+string);
//从集合中删除元素:remove.
String string2=arrayList.remove(0);
System.out.printf("从集合中删除的元素是:"+string2);
//遍历集合
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }

ArrayList集合中若想存放基本数据类型，必须使用基本类型对应的包装类基本类型 包装类（引用类型，都位于java.long包下）
byte ==> Byte
int ==> Integer
short ==> Short
long ==> Long
double ==> Double
float ==> Float
char ==> Character
boolean ==> Boolean

1
2
3
4
5
//int 应用类型举例
ArrayList<Integer> listInt=new ArrayList<>();
listInt.add(100);
listInt.add(300);
System.out.println(listInt.get(0));
看都看了，不说来点什么！