集合基础篇（黑马）
我什么要用集合？
- 自动扩容
集合储存的特点和数组相比
可以发现数组基本数据类型和引用数据类型都可以储存，而集合只能储存引用数据类型，如果储存引用数据类型将会变成 其包装类
- 数组和集合的对比
ArrayList
泛型类
-
常用方法
构造：public ArrayList ()
-
构造方法
package Test;
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListTest {
public static void main(String[] args) {
//构造方法
//ArrayList<String> ar=new ArrayList<String>();
ArrayList<String> ar=new ArrayList<>();//jdk新特性
System.out.println(ar);//[]
}
}
当没有元素时输出[]是由java官方自己实现的，他们将集合里面的元素在输出的时候用[]包裹起来，输出的时候调用AarrayList的toString方法
- add方法
可以重add方法的源代码中可见，add方法不管添加什么其最终的返回值都是true,,所以我们不用关心add方法的返回值
- 删除
package Test;
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListTest {
public static void main(String[] args) {
//remove:删除
//1. boolean remove(E e) 删除指定的元素 返回是否删除成功
ArrayList<String> ar=new ArrayList<>();
ar.add("hello");
ar.add("the");
ar.add("world");
ar.add("hi");
boolean b = ar.remove("the");
System.out.println(b);//true
System.out.println(ar);//[hello, world, hi]
//当集合中没有该元素时将会返回false
boolean b1 = ar.remove("good");
System.out.println(b1);//false
System.out.println(ar);//[hello, world, hi]
//E remove (int index):删除指定索引的元素:返回被删除的元素
String s = ar.remove(0);//删除索引为0的元素
System.out.println(s);//hello
System.out.println(ar);//[world, hi]
//当下标越界将会在运行期间报下标越界异常
ar.remove(2);//IndexOutOfBoundsException
}
}
- 修改
package Test;
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListTest {
public static void main(String[] args) {
//修改：将指定索引的值修改为指定的值:并将原来那个值返回
//E set(int index,E e)
ArrayList<String> ar=new ArrayList<>();
ar.add("hello");
ar.add("the");
ar.add("world");
System.out.println(ar);//[hello, the, world]
//修改
String s = ar.set(1, "a");//将下标是1的值修改为"a"
System.out.println(s);//the
System.out.println(ar);//[hello, a, world]
}
}
- 获取指定索引的元素 get
package Test;
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListTest {
public static void main(String[] args) {
//修改：将指定索引的值修改为指定的值:并将原来那个值返回
//E set(int index,E e)
ArrayList<String> ar=new ArrayList<>();
ar.add("hello");
ar.add("the");
ar.add("world");
System.out.println(ar);//[hello, the, world]
//获取指定索引的元素：返回获取的元素 E get(int index)
String s = ar.get(2);
System.out.println(s);//world
}
}
- 获取集合的长度
package Test;
import java.util.ArrayList;
import java.util.Arrays;
public class ArrayListTest {
public static void main(String[] args) {
//修改：将指定索引的值修改为指定的值:并将原来那个值返回
//E set(int index,E e)
ArrayList<String> ar=new ArrayList<>();
ar.add("hello");
ar.add("the");
ar.add("world");
System.out.println(ar);//[hello, the, world]
//获取指定索引的元素：返回获取的元素 E get(int index)
String s = ar.get(2);
System.out.println(s);//world
//获取集合的长度 int size()
System.out.println(ar.size());//3
//遍历集合内的每一个元素
//快捷键 ar.fori
for (int i = 0; i < ar.size(); i++) {
System.out.println(ar.get(i));
}
}
}
练习：指定要添加元素的数量
package Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//练习：集合的遍历方式
public class ArrayListTest {
public static void main(String[] args) {
Scanner st=new Scanner(System.in);
ArrayList<String> ar=new ArrayList<>();
System.out.println("你需要添加的字符串数量为：");
int num;
num=st.nextInt();
for (int i = 0; i < num; i ++) {
System.out.println("请输入要添加的字符串：");
String str=st.next();
ar.add(str);
}
//遍历并输出集合
System.out.print("[");
for (int i = 0; i < ar.size(); i++) {
if(i!=ar.size()-1)
System.out.print(ar.get(i)+",");
else{
System.out.print(ar.get(i ));
}
}
System.out.print("]");
}
}
package Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//练习：集合的遍历方式
//定义学生类
class Student{
private String name;
private int age;
//无参构造
public Student() {};
public Student(String name,int age){
this.age=age;
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
public class ArrayListTest {
public static void main(String[] args) {
Student st1=new Student("张三",13);
Student st2=new Student("李四",18);
ArrayList<Student> ar=new ArrayList<>();
ar.add(st1);
ar.add(st2);
//遍历
for (int i = 0; i < ar.size(); i++) {
Student stu=ar.get(i);
System.out.print(stu.getName());
System.out.println(stu.getAge());
}
}
}
用循环同时实例化指定个对象，建议用对象数组进行操作，而在集合中添加指定个对象由于集合可以自动拓展长度，可以直接用add添加对象，不用把每个对象都命名，同样的操作用集合更简单
package Test;
import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListTest1 {
public static void main(String[] args) {
//学生类已经被定义好了
Scanner st=new Scanner(System.in);
int num;
System.out.println("你需要录入的对象数量为：");
num=st.nextInt();
ArrayList<Student> ar=new ArrayList<>();
//每次定义一个对象然后添加到集合中
for (int i = 0; i < num; i++) {
Student stu=new Student();
System.out.println("学生的姓名为:");
String name=st.next();
System.out.println("学生的年龄为：");
int age=st.nextInt();
stu.setAge(age);
stu.setName(name);
ar.add(stu);
}
//遍历集合
for (int i = 0; i < ar.size(); i++) {
Student student = ar.get(i);
System.out.print(student.getName()+" ");
System.out.println(student.getAge());
}
}
}
- 不用方法实现--用flag标记
package Test;
import java.util.ArrayList;
import java.util.Scanner;
class User{
private String id;
private String usename;
private String password;
public User() {
}
public User(String id, String usename, String password) {
this.id = id;
this.usename = usename;
this.password = password;
}
public void setId(String id) {
this.id = id;
}
public void setUsename(String usename) {
this.usename = usename;
}
public void setPassword(String password) {
this.password = password;
}
public String getId() {
return id;
}
public String getUsename() {
return usename;
}
public String getPassword() {
return password;
}
}
//用id查找用户信息，查找成功返回true，失败返回false
public class ArrayListTest1 {
public static void main(String[] args) {
User st1=new User("1234","张三","aaa");
User st2=new User("5678","李四","bbb");
User st3=new User("91011","王五","ccc");
ArrayList<User> ar=new ArrayList<>();
ar.add(st1);
ar.add(st2);
ar.add(st3);
//实现按id查找用户信息
Scanner st=new Scanner(System.in);
System.out.println("请输入一个id:");
String myid = st.next();
boolean falg=false;
for (int i = 0; i < ar.size(); i++) {
if(ar.get(i).getId().equals(myid)){
falg =true;
}
}
if(falg==false)
System.out.println("false");
else
System.out.println("true");
}
}
- 使用方法(变形：如果查找成功返回索引，不成功则返回-1，思想一样)
package Test;
import java.util.ArrayList;
import java.util.Scanner;
class User{
private String id;
private String usename;
private String password;
public User() {
}
public User(String id, String usename, String password) {
this.id = id;
this.usename = usename;
this.password = password;
}
public void setId(String id) {
this.id = id;
}
public void setUsename(String usename) {
this.usename = usename;
}
public void setPassword(String password) {
this.password = password;
}
public String getId() {
return id;
}
public String getUsename() {
return usename;
}
public String getPassword() {
return password;
}
}
//用id查找用户信息，查找成功返回true，失败返回false
public class ArrayListTest1 {
public static void main(String[] args) {
User st1=new User("1234","张三","aaa");
User st2=new User("5678","李四","bbb");
User st3=new User("91011","王五","ccc");
ArrayList<User> ar=new ArrayList<>();
ar.add(st1);
ar.add(st2);
ar.add(st3);
boolean c = contains(ar, "1234");
System.out.println(c);//true
}
//用id查找用户信息
public static boolean contains(ArrayList<User> ar,String id){//传入一个集合 一个id
for (int i = 0; i < ar.size(); i++) {
if(ar.get(i).getId().equals(id)){
return true;
}
}
return false;
}
}
如果同时都要返回索引和true，在一个方法中调用另一个方法即可
- 返回多个数据
对于一个函数返回多个相同类型的数据，可以返回一个数组，用数组完全可以做到，但是数组需要考虑长度（下标）如果我们用集合来操作则简单的多）
package Test;
import java.util.ArrayList;
class Phone{
private String brand;
private float price;
public Phone() {
}
public void setBrand(String brand) {
this.brand = brand;
}
public void setPrice(float price) {
this.price = price;
}
public String getBrand() {
return brand;
}
public float getPrice() {
return price;
}
@Override
public String toString() {
return "Phone{" +
"brand='" + brand + '\'' +
", price=" + price +
'}';
}
public Phone(String brand, float price) {
this.brand = brand;
this.price = price;
}
}
public class ArrayListTest2 {
public static void main(String[] args) {
Phone p1=new Phone("小米",1000.0f);
Phone p2=new Phone("apple",800.0f);
Phone p3=new Phone("华为",10000.0f);
ArrayList<Phone> ar=new ArrayList<>();
ar.add(p1);
ar.add(p2);
ar.add(p3);
ArrayList<Phone> s = contain(ar);
System.out.println(s);//[Phone{brand='小米', price=1000.0}, Phone{brand='apple', price=800.0}]
}
public static ArrayList<Phone> contain(ArrayList<Phone> ar){
ArrayList<Phone>ar1=new ArrayList<>();//实例化集合用于储存多个数据
for (int i = 0; i < ar.size(); i++) {
if(ar.get(i).getPrice()<3000){
ar1.add(ar.get(i));
}
}
return ar1;//返回集合
}
}
