系列文章目录
https://blog.csdn.net/qq_57930222/article/details/130398327?spm=1001.2014.3001.5501
https://blog.csdn.net/qq_57930222/article/details/130753473?spm=1001.2014.3001.5501目录
前言：
本系列文章是假设大家有了一定的Java基础之后，在学习的。这里我们简单介绍一下Java里面两个比较常用的类型ArrayList和HashMap。
为了可以在程序中，保存数目不确定的对象，Java提供了一系列特殊的类，这些类可以存储任意类型的对象，并且长度可变，这些类被称系统称为集合。集合类都位于java.util包中，用时必须导包。
一、集合概述
集合按照其存储结构可以分为两大类，单列集合和双列集合。
1.单列集合
单列集合用于存储一系列符合某种规则的元素。本章只介绍ArrayList集合类。
2.双列集合
双列集合用于存储具有键（key）、值（value）映射关系的元素。本章只介绍HashMap集合类。
二、ArrayList
ArrayList内部封装了一个长度可变的数组对象，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组，来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。
1.常用方法介绍
| 方法声明 | 功能描述 |
| boolean add(Object o) | 向集合中添加一个元素 |
| Object get(int index) | 返回集合索引index处 |
| Object remove(int index) | 删除index索引处的元素 |
| int size() | 获取该集合元素个数 |
| boolean idEmpty() | 判断该集合是否为空 |
2.ArrayList初始化
（1）导包：import java.util.ArrayList;
（2）ArrayList初始化
推荐指定数组元素类型，如下（Type代表元素类型）
ArrayList<Type> list = new ArrayList<Type> ();
例如：
ArrayList<String> list = new ArrayList<String> (); //指定了存储元素为String类型
当然也可以指定自己定义的其他类，例如自定义有学生类Student，ArrayList也可以存储学生类型对象。例如：
ArrayList<Student> list = new ArrayList<Student> ();
3.ArrayList案例
（1）案例1，包装类
新建Java project，命名ArrayList1，新建包命名csdn.ah.ArrayList，包下新建类命名ArrayList1.java
编写代码
运行测试
（2）案例2，自定义类
在包csdn.ah.ArrayList下新建类，命名为ArrayList2
编写代码
package csdn.ah.ArrayList;
import java.util.ArrayList;
public class ArrayList2 {
public static void main(String[] args) {
//创建ArrayList类
ArrayList<Person> list = new ArrayList<Person> ();
//通过有参构造函数实例化Person类
Person p1 = new Person("张三",19);
Person p2 = new Person("李四",20);
Person p3 = new Person("王五",21);
Person p4 = new Person("赵六",22);
//将实例化的对象添加到集合中
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
//打印集合的长度
System.out.println("集合的长度为：" + list.size());
//打印出集合中指定位置的元素
System.out.println("集合中第2个位置的元素是：" + list.get(1));
//移除集合中指定位置的元素
list.remove(1);
//再次打印该位置元素
System.out.println("集合中第2个位置的元素是：" + list.get(1));
//打印输出集合元素与集合长度，查看集合是是否有什么变化
for (Person i : list) {
System.out.println(i);
}
System.out.println("集合的长度为：" + list.size());
}
}
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Person[name=" + name + ",age=" + age + "]";
}
}运行测试
三、HashMap
HashMap是一种双列集合，它的每一个元素都包含一个键对象Key和值对象Value，键和值对象中存在一种映射关系，称为映射。
从HashMap中访问元素时只要指定了Key，就能找到对应得Value。
1.常用方法简介
| 方法声明 | 功能描述 |
| void put(Object Key, Object Value) | 将指定的值与此映射中的指定键关联(可选操作) |
| Object get(Object Key) | 返回指定键所映射的值，如果此映射不包含改键的映射关系，则返回null |
| V remove(Object Key) | 根据键删除对应的值，返回被删除的值 |
| int size() | 返回集合中的键值对的个数 |
2.HashMap初始化
（1）导包：import java.util.HashMap;
（2）HashMap初始化推荐指定关键字和值类型如下(k代表元素关键字(Key)的类型，v代表元素值(Value)的类型)：
HashMap<k,v>map = new HashMap<k,v> ();
例如：
HashMap<String,Object> map = new HashMap<String,Object>();
指定了存储元素的关键字为String类型，值为Object类型
3.HashMap案例
（1）HashMap
新建Dynamic项目命名为HashMap，新建包csdn.ah.HashMap，包下新建类hashMap
编写代码
package csdn.ah.HashMap;
import java.util.HashMap;
public class hashMap {
public static void main(String[] args) {
//创建HashMap对象
HashMap<String,String> map = new HashMap<String,String>();
//存储键和值
map.put("1", "张三");
map.put("2", "李四");
map.put("3", "王五");
map.put("4", "赵六");
//根据键获取值
System.out.println("1:" + map.get("1"));
System.out.println("2:" + map.get("2"));
System.out.println("3:" + map.get("3"));
System.out.println("4:" + map.get("4"));
//存储相同的键
map.put("3", "甲一");
//打印查看键为3的值现在为多少
System.out.println("3:" + map.get("3"));
}
}
运行测试
（2）存储跟学生有关的数据，包括(学号、姓名、性别、年龄、班级)
新建一个类命名为hashMap2.java，位于包csdn.ah.HashMap下
编写代码
package csdn.ah.HashMap;
import java.util.HashMap;
import java.util.ArrayList;
public class hashMap2 {
public static void main(String[] args) {
//创建HashMap集合
HashMap<String,Object> map1 = new HashMap<String,Object>();
HashMap<String,Object> map2 = new HashMap<String,Object>();
HashMap<String,Object> map3 = new HashMap<String,Object>();
//为map集合添加键值对
map1.put("id", 1);
map1.put("name", "张三");
map1.put("sex", "男");
map1.put("age", 21);
map1.put("class", "一班");
map2.put("id", 2);
map2.put("name", "李四");
map2.put("sex", "女");
map2.put("age", 22);
map2.put("class", "二班");
map3.put("id", 3);
map3.put("name", "王五");
map3.put("sex", "男");
map3.put("age", 23);
map3.put("class", "三班");
//创建ArrayList集合
ArrayList<Object> list = new ArrayList<Object>();
//将HashMap对象添加到ArrayList集合中
list.add(map1);
list.add(map2);
list.add(map3);
//将list中的数据打印出来查看
for(Object i : list) {
System.out.println(i);
}
}
}运行测试
（3）static静态
在定义一个类时，只是在描述某事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象时，才会开辟栈内存及堆内存，在堆内存中要保存对象的属性时，每个对象会有自己的属性。
如果希望某些属性被所有对象共享，就必须将其声明为static属性。除了修饰属性，static关键字还可以修饰成员方法。
静态属性：
如果在Java程序中使用static修饰属性，则该属性称为静态属性(也称全局属性)。静态属性可以使用类名直接访问，访问格式如下：
类名.属性名
静态属性案例：
新建Dynamic项目命名为Static，新建包csdn.ah.Static，包下新建类命名为static1.java
编写代码
package csdn.ah.Static;
public class static1 {
public static void main(String[] args) {
//实例化Student对象
Student stu1 = new Student("张三",19);
Student stu2 = new Student("李四",20);
Student stu3 = new Student("王五",21);
//打印这三个对象
stu1.info();
stu2.info();
stu3.info();
}
}
//创建Student类
class Student{
private String name;
private int age;
public static String school = "A大学";
public Student() {
}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public void info() {
System.out.println("姓名：" + this.name + ",年龄：" + this.age + ",school:" + school);
}
}测试运行
我们对代码稍作修改，集体修改他们所在的大学
运行查看结果：
静态方法：
如果想要用类中的成员方法，就需要先将这个类实例化。而在实际开发时，开发人员有时希望在不创建对象的情况下，通过类名就可以调用某个方法，要实现这样的效果，只需要在成员方法上加上static关键字，使用static关键字修饰的方法通常成为静态方法。
静态方法也可以通过类名访问，具体如下：
类名.方法名
静态方法案例：
在包csdn.ah.Static下新建类命名为static2
编写代码
package csdn.ah.Static;
public class static2 {
public static void main(String[] args) {
//实力化Student1类
Student1 stu4 = new Student1("张三",19);
Student1 stu5 = new Student1("李四",20);
Student1 stu6 = new Student1("王五",21);
//调用Student1类的静态方法setSchool()集体修改大学名
Student1.setSchool("C大学");
//调用共有方法info()打印这三个对象
stu4.info();
stu5.info();
stu6.info();
}
}
//创建Student类
class Student1{
private String name;
private int age;
private static String school = "A大学";
public Student1() {
}
public Student1(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static String getSchool() {
return school;
}
public static void setSchool(String school) {
Student1.school = school;
}
public void info() {
System.out.println("姓名：" + this.name + ",年龄：" + this.age + ",school:" + school);
}
}运行测试
静态代码块：
在Java类中，用static关键字修饰的代码块被称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。
在程序中，通常使用静态代码块对类的成员变量进行初始化。
静态代码块案例：
在包csdn.ah.static下新建类，命名为static3
编写代码
package csdn.ah.Static;
public class static3 {
public static void main(String[] args) {
//实例化Student3类
Student3 stu7 = new Student3("张三",19);
Student3 stu8 = new Student3("李四",20);
Student3 stu9 = new Student3("王五",21);
//打印这三个对象
stu7.info();
stu8.info();
stu9.info();
}
}
//创建Student类
class Student3{
private String name;
private int age;
public static String school;
static {
System.out.println("进入静态代码块");
//初始化school字段
school = "A大学";
}
public Student3() {
System.out.println("无参构造函数");
}
public Student3(String name,int age) {
System.out.println("有参构造函数");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static String getSchool() {
return school;
}
public static void setSchool(String school) {
Student3.school = school;
}
public void info() {
System.out.println("姓名：" + this.name + ",年龄：" + this.age + ",school:" + school);
}
}运行测试
总结：
本章内容我们学习/复习了Java有关的两个复杂类型，ArrayList、HashMap，顺便学习了静态属性、静态方法、静态代码块三个知识，这都将为我们之后的内容打下基础。下一章我们将进入到项目实战之中，编写一个使用静态页面编写一个学生管理系统，该部分内容过多我们将分多期实现。关注我，获取最新内容。
1252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
