1. 首页首页
  2. 编程笔记编程笔记

怎么把java彻底删除

编程笔记 • • 阅读 25

常用方法 解释 add([int index],E element)和addAll([int index],Collection c) 增加元素，起始位置为0 object get(int index) 通过索引号，获取元素值 boolean contains(Object o) 判断元素是否存在，返回boolean值 boolean

常用方法解释
add([int index],E element)和addAll([int index],Collection c)增加元素，起始位置为0
 object get(int index)通过索引号，获取元素值
boolean contains(Object o)判断元素是否存在，返回boolean值
boolean containsAll(Collection c)判断元素是否存在，返回boolean值
size()返回集合数量（对象是行数）

boolean  contains

boolean containsAll(Collection c)

判断元素是否存在
set(int index,Object o)覆盖或修改元素值 
indexOf(Object o) 起始位置为0，查某个指定的字符串在字符串首次出现的位置(索引值)，前往后查 
lastIndexOf(Object o)反向顺序，是从右向左查某个指定的字符串在字符串中最后一次出现的位置也，从后往前查。
toArray()把内容放到数组中

iterator()

listIterator([int index]) 

迭代器

remove(int index)

remove(Object o)

removeAll(Collection c)

删除元素

IsEmpty()

判断元素值是否为空
clear()清空集合

 

 

 

 

 

 

0.【一个菜鸟被绕晕的问题】

List m_student = new ArrayList(); // 建立一个空的ArrayList集合

ArrayList m_student = new ArrayList(); // 建立一个空的ArrayList集合

List m_student = new LinkedList(); // 建立一个空的ArrayList集合

LinkedList m_student = new LinkedList(); // 建立一个空的ArrayList集合

到底是用List 还是用ArrayList？其实后面的方法不一样。LIst是通用方法，而ArrayList和LinkedList有自己的方法。

 

 一、把单独的“字符串”存入到ArrayList容器类中。 

 

package book;
import java.util.ArrayList;
public class book {

	public static void main(String[] args) {
		
		ArrayList<String> m_book = new ArrayList<String>();  // 声明一个对象 
		
		// ======== 【添加】往m_book中添加内容，每个内容一个元素。
		
		m_book.add("1、《Java大全》");
		m_book.add("2、《Excel入门》");
		m_book.add("3、《Word精通》");
		m_book.add("4、《HTML指南》");
		m_book.add("5、《SQL数据库基础》");
		
		m_book.add(1,"2、《php攻略》");  // 在第1个元素之前接入内容，注意：是从0开始的，这里的1就是2.
		
		// 循环遍历出 m_book中每一个元素的值。 
		
		for(String i:m_book)
		{
			System.out.println(i);
		}
		
		// ======= 【删除】删除m_book某元素的值。 

		System.out.println("---------- 删除某个元素");
		m_book.remove(2);  // 删除第2个元素，注意：从0开始计算，这里的2就是3.
		for(String i:m_book)
		{
			System.out.println(i);
		}
		
		System.out.println("--------- 按内容删除");
		m_book.remove("5、《SQL数据库基础》");  // 按内容删除，注意：内容要一模一样.
		for(String i:m_book)
		{
			System.out.println(i);
		}
		
		System.out.println("---------------\\ 清空");
		 m_book.clear();  // 清空内容.
		for(String i:m_book)
		{
			System.out.println(i);
		}
		
		// ======= 【修改或替换】m_book某元素的值。 
		
		System.out.println("------- \\ 修改替换某个元素内容");
		m_book.add("1、《Java大全》");
		m_book.add("8、《Excel入门》");
		m_book.add("3、《Word精通》");
		m_book.add("4、《HTML指南》");
		m_book.add("5、《SQL数据库基础》");
		
		m_book.set(1,"2、《Excel入门》"); // 替换第1个元素内容，注意，从0开始，这里的1是2.
		
		for(String i:m_book)
		{
			System.out.println(i);
		}
		
		// ======= 【查询】某一个元素的值。 
		
		System.out.println("------- \\ 查询】某一个元素的值");
		
		String aaa=m_book.get(1); // 替换第1个元素内容，注意，从0开始，这里的1是2.
		
		System.out.println("第二个元素值是："+aaa);
		
	}

}

二、把一个类的“数组值”存入到ArrayList容器类中。

1、database.java 

package Book;
import java.util.ArrayList;
import org.omg.CORBA.PUBLIC_MEMBER;

public class database {

	private ArrayList<book> ListBook = new ArrayList<book>();  // book.java类关联ArrayList

	public void add(book booklist) // 往ArrayList中添加book类数组格式的内容
	{
		ListBook.add(booklist);
	}		
	
	public void list()  // 遍历ListBook中的值
	{
		for (book booklist : ListBook)
		{
			booklist.print(); // 调用book中的print方法
		}
	}
		
	public static void main(String[] args)  // 向ArrayList中写入内容
	{
	 database aaa = new database();
	 aaa.add(new book("JAVA语言开发", 45, 568, "张杰"));
	 aaa.add(new book("Python开发", 88, 300, "牛人"));
	 aaa.list();
	}
}

2、Book.java 

package Book;
public class book {

    // ================= 建立了书的参数，也可以叫字段名
	
	private String name;  // 书的名称
	private int price; // 书的价格
	private int page; // 书的页数
	private String men; // 书的作
	
	public book(String name, int price, int page, String men) // 调用参数 
	{
		//super();
		this.name = name;
		this.price = price;
		this.page = page;
		this.men = men;
	}

	public void print()  // 显示内容
	{
		System.out.println("书名"+name+"    价格"+price+"元");
		
	}
	public static void main(String[] args) {

	}


}

三、ArrayList的另一个操作构造函数的实例 

1、Student.java (构造函数类)

package z_ArrayList;

public class Student {
	

	private int id;   // 编号
	private String name;// 姓名
	private String old;// 年龄
	
	public Student() {}
	public Student(int id, String name, String old) {

		this.id = id;
		this.name = name;
		this.old = old;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getOld() {
		return old;
	}
	public void setOld(String old) {
		this.old = old;
	}	
	
}

2、AList.java（操作类）

package z_ArrayList;

import java.util.*;
public class AList {

	public static void main(String[] args) 
	{
		
		List m_student = new ArrayList();  // 建立一个空的ArrayList集合
		Student student_1=  new Student(1,"张三","15");  // 实例化Student类，并存入数据"
		Student student_2=  new Student(2,"李四","16");
		Student student_3=  new Student(2,"李四","16");
		
		// --------- 添加(是追加，不是插入) add
		
		m_student.add(student_1);  // 把类存入数组ArrayList中 
		m_student.add(student_2);
		m_student.add(new Student(3,"王五","18"));  // 也可以直接写入类对象

		m_student.add(new Student(2,"店小二","15"));  // 在最后插入一行数据
		
		
		
		System.out.println("学生信息的行数："+m_student.size());  // 判断对象数组有几行
		
		// ----------  查询和遍历 for
		
		for(int i=0;i<m_student.size();i++)
		{
			Student student = (Student)m_student.get(i);
			System.out.println("第"+student.getId()+"行的学生信息的姓名："+student.getName()+"  年龄："+student.getOld());
		}
		
		// ------------ 判断对象是否存在contains
		System.out.println(m_student.contains(student_2)); // 【contains】判断是含否有对象，返回true		
		System.out.println(m_student.contains(student_3)); // 【contains】判断是含否有对象，是指针对比，不是值对比,所以返回false
		System.out.println(m_student.contains(new Student(3,"王五","18"))); // 【contains】判断是含否有对象，是指针对比，不是值对比,所以返回false
		
		m_student.remove((student_2)); // 【remove】删除元素		
		m_student.remove((new Student(2,"店小二","15"))); // remove，不能删除值，所以无效		
		m_student.remove(2); // remove，不能删除值，但可以用【索引号】，所以，这个可行，从0开始计算
		
		System.out.println(m_student.contains(student_2)); // 因为删除了，所以返回为false
		m_student.set(0,new Student(2,"张三被我替换了","15")); // set，修改元素值	
		
		for(int i=0;i<m_student.size();i++)
		{
			Student student = (Student)m_student.get(i);
			System.out.println("第"+student.getId()+"行的学生信息的姓名："+student.getName()+"  年龄："+student.getOld());
		}
		
	}

}

四、ArrayList的泛型实例 

为什么要用泛型？不用再GET获取值时，强制转换格式了。

正常：List m_student = new ArrayList(); 

泛型：List<Student> m_student = new ArrayList<Student>();  把构造函数格式或数据类型存入了。

正常get调用： Student student = (Student)m_student.get(i);

泛型get调用： Student student = m_student.get(i);

package z_ArrayList;

import java.util.ArrayList;
import java.util.List;

public class fanxing {

	public static void main(String[] args) {
		List<Student> m_student = new ArrayList<Student>();  // 建立一个空的ArrayList集合
		// List m_student = new ArrayList();  // 建立一个空的ArrayList集合

		Student student_1=  new Student(1,"张三","15");  // 实例化Student类，并存入数据"
		Student student_2=  new Student(2,"李四","16");
		Student student_3=  new Student(2,"李四","16");	
		
		// --------- 添加(是追加，不是插入) add
		
		m_student.add(student_1);  // 把类存入数组ArrayList中 
		m_student.add(student_2);
		m_student.add(new Student(3,"王五","18"));  // 也可以直接写入类对象

		m_student.add(new Student(2,"店小二","15"));  // 在最后插入一行数据
		
		
		
		System.out.println("学生信息的行数："+m_student.size());  // 判断对象数组有几行
		
		// ----------  查询和遍历 for
		
		for(int i=0;i<m_student.size();i++)
		{
			Student student = m_student.get(i);
			System.out.println("第"+student.getId()+"行的学生信息的姓名："+student.getName()+"  年龄："+student.getOld());
		}
		
		// ------------ 判断对象是否存在contains
		System.out.println(m_student.contains(student_2)); // 【contains】判断是含否有对象，返回true		
		System.out.println(m_student.contains(student_3)); // 【contains】判断是含否有对象，是指针对比，不是值对比,所以返回false
		System.out.println(m_student.contains(new Student(3,"王五","18"))); // 【contains】判断是含否有对象，是指针对比，不是值对比,所以返回false
		
		m_student.remove((student_2)); // 【remove】删除元素		
		m_student.remove((new Student(2,"店小二","15"))); // remove，不能删除值，所以无效		
		m_student.remove(2); // remove，不能删除值，但可以用【索引号】，所以，这个可行，从0开始计算
		
		System.out.println(m_student.contains(student_2)); // 因为删除了，所以返回为false
		m_student.set(0,new Student(2,"张三被我替换了","15")); // set，修改元素值		
	
		
		for(int i=0;i<m_student.size();i++)
		{
			Student student = m_student.get(i);   // 不用强转了。
//			Student student = (Student)m_student.get(i);
			System.out.println("第"+student.getId()+"行的学生信息的姓名："+student.getName()+"  年龄："+student.getOld());
		}
	}

}

五、ArrayList排序、最大值、最小值(单项值)

package z_ArrayList;

import java.util.*;
public class z_Sort {

	public static void main(String[] args) {
		
		List<String> m_list=new ArrayList<String>();
		m_list.add("C1");
		m_list.add("Z2");
		m_list.add("L3");
		m_list.add("z2");
		m_list.add("Q4");
		
		System.out.println("======= 对字符型最大值、最小值、排序 ========\n");
		System.out.println( "最大值是："+Collections.max(m_list));
		System.out.println( "最小值是："+Collections.min(m_list));
		System.out.println("\n== 正常排序 ==\n");

		Collections.sort(m_list);
		for(int i=0;i<m_list.size();i++){
			System.out.println( m_list.get(i));
		}
		
		System.out.println("\n== 倒排序 ==\n");
		
		Collections.reverse(m_list);   // reverse，倒序
		for(int i=0;i<m_list.size();i++){
			System.out.println( m_list.get(i));
		}
		
		System.out.println("\n======= 对数字，最大值、最小值、排序 ========\n");
		
		List<Integer> mm_list=new ArrayList<Integer>();
		mm_list.add(1);
		mm_list.add(2);
		mm_list.add(3);
		mm_list.add(4);
		mm_list.add(5);
		
		System.out.println( "最大值是："+Collections.max(mm_list));
		System.out.println( "最小值是："+Collections.min(mm_list));
		System.out.println("\n== 正常排序 ==\n");

		Collections.sort(mm_list);
		for(int i=0;i<mm_list.size();i++){
			System.out.println( mm_list.get(i));
		}
		
		System.out.println("\n== 倒排序 ==\n");
		
		Collections.reverse(mm_list);   // reverse，倒序
		for(int i=0;i<mm_list.size();i++){
			System.out.println( mm_list.get(i));
		}
		

	}

}

五、ArrayList排序、最大值、最小值(多个对象的集合)

1.Student.java(构造函数类)

两个关键点：基于compareTo实现。

1、public class Student implements Comparable {

2、这段代码

	// ========== 按学号排序方法
	
	public int compareTo(Object o)
	{
		Student student=(Student)o;
		if(this.id==student.id)
		{
			return 0;
		}
		else if(this.id>student.id) 
		{		
			return 1;
		}
		else if(this.id<student.id) 
		{
			return -1;
		}
		 return 0;
	}

完整代码：

package z_ArrayList;

public class Student implements Comparable {
	

	private int id;   // 编号
	private String name;// 姓名
	private String old;// 年龄
	
	public Student() {}
	public Student(int id, String name, String old) {

		this.id = id;
		this.name = name;
		this.old = old;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getOld() {
		return old;
	}
	public void setOld(String old) {
		this.old = old;
	}
	
	// ========== 按学号排序方法
	
	public int compareTo(Object o)
	{
		Student student=(Student)o;
		if(this.id==student.id)
		{
			return 0;
		}
		else if(this.id>student.id) 
		{		
			return 1;
		}
		else if(this.id<student.id) 
		{
			return -1;
		}
		 return 0;
	}
		
}

2.Sort.java(排序、最大化、最小化类)

主要是：Collections.sort(m_student);

package z_ArrayList;

import java.util.*;

public class Sort {

	public static void main(String[] args) {
		

			List<Student> m_student = new ArrayList<Student>();  // 建立一个空的0ArrayList集合

			Student student_1=  new Student(3,"张三","15");  // 实例化Student类，并存入数据"
			Student student_2=  new Student(1,"李四","18");
			Student student_3=  new Student(2,"周二","17");	
			Student student_4=  new Student(4,"王五","16");	
			
			m_student.add(student_1);  // 把类存入数组ArrayList中 
			m_student.add(student_2);
			m_student.add(student_3);
			m_student.add(student_4);
			
			// ----------  查询和遍历 for
			
			Collections.sort(m_student);
			
			for(int i=0;i<m_student.size();i++)
			{
				Student student = m_student.get(i);
				System.out.println(student.getId()+" "+student.getName()+"  年龄："+student.getOld());
			}

	}
}

 

 

 

 

 

 

 

知秋君
知秋君

知秋君

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请关注公众号“全栈程序员社区”联系小编举报，一经查实，本站将立刻删除。
上一篇 2024-07-08 19:02
下一篇 2024-07-08 18:36

相关推荐