12.08Java

已于 2024-12-09 20:08:24 修改
阅读量175 收藏
点赞数 2
CC 4.0 BY-SA版权
文章标签： java 算法 数据结构
于 2024-12-08 17:38:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Jsjendndn/article/details/144327477

今天学习了Java基本集合接口 

public static void main(String[] args) {
		int a[]= {3,4,1,8,7,9,10,2,5,6};
		int b[]= new int[10];
		System.arraycopy(a, 2, b, 7, 3);
		Arrays.sort(a);
		for (int i = 0; i < b.length; i++) {
			System.out.print(b[i]+" ");
		}
		System.out.println();
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		

	}

public static void main(String[] arg) {
		int a[]= {1,2,5,6,8,7,9,4,3,10};
		Arrays.sort(a);
		for (int i= 0 ;i<a.length;i++ ) {
			System.out.print(a[i]+" ");
		}
		int b=Arrays.binarySearch(a, 8);
//		返回查找元素的下标
		System.out.println(b);
	}
public static void main(String[] arg) {
		int a[]= {1,2,5,6,8,7,9,4,3,10};
		int b[]= {1,2,3};
		int c[]= {1,2,3};
		System.out.println(Arrays.equals(a, b));
		System.out.println(Arrays.equals(c, b));
	}
public static void main(String[] arg) {
		ArrayList<String> a =new ArrayList<String>();
		ArrayList<String> b =new ArrayList<String>();
		a.add("aaa");
		a.add("bbb");
		a.add("ccc");
		a.add("ddd");
		b.add("123");
		b.add("456");
		b.add("789");
		System.out.println(a);
		System.out.println(b);
		System.out.println("-----------------------------");
		a.remove(0);
		System.out.println(a);
		System.out.println(a.contains("aaa"));
		System.out.println(a.indexOf("ccc"));
		System.out.println("-----------------------------");
		a.addAll(b);
		System.out.println(a);
		a.removeAll(b);
		a.removeAll(a);
		System.out.println(a);
		
		
	}

	public static void main(String[] arg) {
		ArrayList<String> a =new ArrayList<String>();
		a.add("aaa");
		a.add("bbb");
		a.add("ccc");
		a.add("ddd");
//		使用Iterator输出
		Iterator<String> iter = a.iterator();
		while(iter.hasNext()) {
			System.out.print(iter.next()+" ");
		}
		System.out.println();
//		使用forEach输出
		for (String s : a) {
			System.out.print(s+" ");
		}
		System.out.println();
//		使用toString输出
		System.out.println(a);
		
//		使用for循环输出
		for (int i = 0; i < a.size(); i++) {
			System.out.print(a.get(i)+" ");
		}
		
	}
	


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class HelloAdd {
	static ArrayList playerArray= new ArrayList();
	static List subListObj = new ArrayList();

	public static void main(String[] args) {
	add();
	display();
	System.out.println();
	search();
	System.out.println();
	extract();
	}

	static void add() {
	       for (int i = 0; i < 5; i++) {
	            playerArray.add(new Integer(i));
	       }
	        playerArray.add("Martina");
	        playerArray.add("Serena");
	        playerArray.add("Venus");
	        playerArray.add("Serena");
	}

	static void display() {
	       System.out.println("**************************************");
	       System.out.println("从 ArrayList 中检索对象");
	       System.out.println("**************************************");
	       System.out.println();
	       for (int i = 0; i < playerArray.size(); i++) 
	             System.out.print(" " + playerArray.get(i));
	     }
	static void search() {
	    System.out.println("***********************************************************");
	    System.out.println("搜索一个对象并返回第一个和最后一个位置");
	    System.out.println("************************************************************");
	    System.out.println("字符串\"Serena\"第一次出现在位置是 "+ playerArray.indexOf("Serena"));
	    System.out.println("字符串\"Serena\"最后一次出现在位置是 " 
	                                                + playerArray.lastIndexOf("Serena"));
	    System.out.println();    
	    }
	static void extract() {
	    System.out.println("************************************************");
	    System.out.println("提取一个子列表，然后输出新列表");
	    System.out.println("*************************************************");
	    System.out.println();
	    subListObj = playerArray.subList(5, playerArray.size());
	    System.out.println("索引 5 至"+playerArray.size()+"的新子列表为："
	                                     + subListObj);
	    System.out.println();
	}

	
	
}

public static void main(String[] args) {
//		案例1：编写一个交错合并列表元素的程序。
//        例如：给定的两个列表为[a，B，C]和[1，2，3]，函数返回[a，1，B，2，C，3]。
//        若两个表元素个数不同，多余的附在合并表的尾
		ArrayList<String> a = new ArrayList<String>();
		ArrayList<String> b = new ArrayList<String>();
		ArrayList<String> c = new ArrayList<String>();
		a.add("a");
		a.add("B");
		a.add("C");
		a.add("d");
		a.add("e");
		b.add("1");
		b.add("2");
		b.add("3");
		int length = a.size()>b.size()?b.size():a.size();
		for(int i = 0;i<length;i++) {
			c.add(a.get(i));
			c.add(b.get(i));
		}
		
		if(a.size()>b.size()) {
			for(int i=b.size();i<a.size();i++) {
				c.add(a.get(i));
			}
		}else if(a.size()<b.size()) {
			for(int i=a.size();i<b.size();i++) {
				c.add(b.get(i));
			}
		}
		for (int i = 0; i < c.size(); i++) {
			System.out.print(c.get(i)+" ");
		}
		
	}
	public static void main(String[] args) {
//		案例2：编写一个计算斐波那契数的程序。根据定义，斐波那契序列的前两位数字是0和1，
//		随后的每个数字是前两个数字的和。要求输出直到某项的值刚大于10000的前面所有项。
//		例如，前11位（刚大于50的前所有项）斐波那契数为：0，1，1，2，3，5，8，13，21，34，55。
		ArrayList<Integer> a = new ArrayList<>();
		a.add(0);
		a.add(1);
		int count2 =0;
		int count = 1;
		for(int i=0;;i++) {
			a.add(a.get(i)+a.get(i+1));
			count+=a.get(i+2);
			if(count>10000) {
				count2 = count-a.get(i+2);
				 break;
			}
		}
		System.out.println(count2+" "+count);
		
	}


//法二：
public static void main(String[] args) {
        // 创建一个存储斐波那契数列的ArrayList
        ArrayList<Integer> fibonacciList = new ArrayList<>();
        fibonacciList.add(0);
        fibonacciList.add(1);

        // 计算斐波那契数列
        while (true) {
            int nextFibonacci = fibonacciList.get(fibonacciList.size() - 1) + fibonacciList.get(fibonacciList.size() - 2);
            if (nextFibonacci > 10000) {
                break; // 如果当前数值大于10000，则退出循环
            }
            fibonacciList.add(nextFibonacci);
        }

        // 输出结果
        System.out.println("斐波那契数列（直到大于10000的前面所有项）为：" + fibonacciList);
    }
	public static void main(String[] args) {
       
	

//	案例3：任意从键盘输入若干学生的成绩，当输入-1时，停止输入数据，计算这些数据的平均成绩，
//	并输出高于平均成绩的值。
//	分析：
//	 （1） 定义一个存放成绩的容器，每输入一个成绩，就将成绩添加到数组中，直到输入完成。
//	 （2）计算总成绩、平均成绩。
//	 （3）输出高于平均成绩的值。
		Scanner cin = new Scanner(System.in);
		double score = 0;
		score = cin.nextDouble();
		List<Double> arr = new ArrayList<>();
		while(score!=-1) {
			arr.add(score);
			score = cin.nextDouble();
		}
		for (Double integer : arr) {
			System.out.print(integer+" ");
		}
		System.out.println();
		double sum = 0;
		for(Double i:arr) {
			sum+=i;
		}
		double average = sum/arr.size();
		System.out.println("总成绩："+sum+" "+"平均成绩："+average);
		System.out.println("高于平均成绩的：");
		for(Double i : arr) {
			if(i>average) {
				System.out.println(i+" ");
			}
		}
		
		
		
		cin.close();
	}
public static void main(String[] args) {
		LinkedList mylist = new LinkedList();
	     Student    stu_1 = new Student("赵一", 9012, 80.0f), 
                           stu_2 = new Student("钱二", 9013, 90.0f),
                           stu_3 = new Student("孙三", 9014, 78.0f), 
                           stu_4 = new Student("周四", 9015, 55.0f);
	     mylist.add(stu_1);
	     mylist.add(stu_2);
	     mylist.add(stu_3);
	     mylist.add(stu_4);
	     Iterator<Student> iter =  mylist.iterator();
	     while(iter.hasNext()) {
	    	 Student s = iter.next();
	    	 s.printStudent();
	     }
	}
	
	

class Student {
	private String name;
	private int number;
	private float score;
	public Student(String name, int number, float score) {
		this.name = name;
		this.number = number;
		this.score = score;
	}
    public void printStudent(){
        System.out.println(name + " " +number + "  " + score);
     }
}

总结：

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机访问get和set，ArrayList绝对优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

       

public static void main(String[] args) {
//        HashSet是Set接口的一个子类，主要的特点是：里面不能存放重复元素，
//        而且采用散列的存储方法，所以没有顺序。
//        这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致。

		Set set1 = new HashSet();
		set1.add("a");
		set1.add("b");
		set1.add("a");
		set1.add("c");
		set1.add("d");
		
		Iterator iter = set1.iterator();
		while(iter.hasNext()) {
			System.out.print(iter.next()+" ");
		}
	}

//很巧妙的写法，把add写到if中去了。

public static void main(String[] args) {
		HashSet  set = new HashSet();
        Scanner sc=new Scanner(System.in);
        String ss=null;
        ss=sc.next();
        while(!ss.equals("end")) {       
            if (!set.add(ss))
                  System.out.println("重复的单词: "+ss);
            ss=sc.next();
        }
        System.out.print("形成的集合为: "+set);        
    }

//常规写法

public static void main(String[] args) {
		HashSet  set = new HashSet();
        Scanner sc=new Scanner(System.in);
        String ss=null;
        ss=sc.next();
        while(true) {
        	ss = sc.next();
        	if(ss.equals("end")) {
        		break;
        	}
        	if(!set.contains(ss)) {
        		set.add(ss);
        	}else {
        		System.out.println("重复元素为："+ss);
        	}
        	
        	
        	
        }
        System.out.print("形成的集合为: "+set);        
    }

还有TreeSet和Map没有写

public static void main(String[] args) {
//	       TreeSet类创建的对象称为树集。树集是由一些节点对象组成的数据结构	
//	       节点按着树形一层一层的排列。
//	       树集是个有序集合，可以按照任何顺序将元素插入该集合，
//	       该元素将被纳入它的相应的排序位置；
//	       当迭代通过该集合时，各个值将自动按照排序后的顺序出现。
		Set s1 = new TreeSet();
		s1.add("bbb");
		s1.add("aaa");
		s1.add("ddd");
		s1.add("ccc");
		Iterator iter = s1.iterator();
		while(iter.hasNext()) {
			System.out.println(iter.next());
		}
    }
//输出：
//aaa
//bbb
//ccc
//ddd

一般，Java中通过接口实现两个对象的比较，比较常用就是Comparable接口和Comparator接口。首先类要实现接口，并且使用泛型规定要进行比较的对象所属的类，然后类实现了接口后，还需要实现接口定义的比较方法（compareTo方法或者compare方法），在这些方法中传入需要比较大小的另一个对象，通过选定的成员变量与之比较，如果大于则返回1，小于返回-1，相等返0。        

1、Comparable和Comparator都是用来实现集合中元素的比较、排序的。        

2、Comparable是在类内部定义的方法实现的排序，位于java.lang下。        

3、Comparator是在类外部实现的排序，位于java.util下。        

4、实现Comparable接口需要覆盖compareTo方法，实现Comparator接口需要覆盖compare方法。

package edu.sdau;

import java.util.TreeSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;


public class HelloAdd {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<>();

        ts.add(new Person("Tom", 24));
        ts.add(new Person("Jerry", 21));
        ts.add(new Person("Brown", 26));
        ts.add(new Person("Bob", 28));
        ts.add(new Person("Brown", 21));
        ts.add(new Person("Brown", 21));

        Iterator<Person> it = ts.iterator();
        while (it.hasNext()) {
            Person p = it.next();
            System.out.println(p.getName() + ":" + p.getAge());
        }
    }

}

class Person implements Comparable<Person> {
    private String name;
    private int age;

    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;
    }

    @Override
    public int compareTo(Person p) {
        int temp1 = this.name.compareTo(p.name);
        return temp1 == 0 ? this.age - p.age : temp1; // 姓名相同时比较年龄
    }
}


    
    


package edu.sdau;

import java.util.TreeSet;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;


public class HelloAdd {
    public static void main(String[] args) {
    	TreeSet<Student> set = new TreeSet<>(new StudentComparator());   
        set.add(new Student(80));   
        set.add(new Student(90));   
        set.add(new Student(60));   
        set.add(new Student(70));   
           
        System.out.println(set);   
        }
    }


  
class Student {   
    int score;   
  
    public Student(int score) {   
        this.score = score;   
    }   
       
    public String toString() {   
        return String.valueOf(score);   
    }   
}   
  
class StudentComparator implements Comparator<Student> {   
  
    // 按学生成绩升序    
    public int compare(Student s1, Student s2) {   
        return s1.score - s2.score;   
    }   
}  
    


package edu.sdau;

import java.util.TreeSet;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;


public class HelloAdd {
    public static void main(String[] args) {
    	TreeSet ts = new TreeSet(new ComparatorByLength());
		ts.add("aaaaa");
		ts.add("abaaa");
		ts.add("zz");
		ts.add("nbaq");
		ts.add("cba");
		ts.add("abc");
		Iterator it = ts.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
    }
}

class ComparatorByLength implements Comparator{
	public int compare(Object o1,Object o2) {
		String s1 = (String)o1;
		String s2 = (String)o2;
		int temp = s1.length()-s2.length();
		return temp == 0?s1.compareTo(s2) : temp;
	}
//	这是一个三元表达式，它首先判断temp是否等于 0，也就是判断两个字符串长度是否相等。
//	如果temp等于 0，说明长度相等，此时通过调用s1的compareTo方法（比较字母）进一步比较
//	字符串内容的字典序，按照字典序比较的结果返回相应的值（小于返回负整数，
//	等于返回 0，大于返回正整数）；如果temp不等于 0，直接返回temp，
//	也就是基于长度比较得出的差值，这个差值本身就体现了两个字符串某种程度上的 “大小” 关系，
//	长度长的字符串在这种比较逻辑下被认为 “更大”。
}

       Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。

       如果程序中存储了几百万个学生，而且经常需要使用学号来搜索某个学生，那么这个需求有效的数据结构就是Map

package edu.sdau;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HelloAdd {
    public static void main(String[] args) {
//    	创建String类型的key和String类型的value
    	Map<String,String> m = new HashMap<String,String>();
    	m.put("a", "john");
    	m.put("b", "Tom");
    	m.put("c", "Jerry");
    	m.put("d", "nb");
    	System.out.println(m);
//    	创建Integer类型的key和String类型的value
    	HashMap<Integer,String> m2 = new HashMap<Integer,String>();
    	m2.put(1, "hello");
    	m2.put(2, "world");
    	m2.put(3, "main");
    	System.out.println(m2);
//    	使用get只能获取key对应的value
    	System.out.println(m2.get(3));
//    	使用 remove(key) 方法来删除 key 对应的键值对(key-value):
    	m2.remove(1);
    	System.out.println(m2);
//    	删除所有键值对(key-value)可以使用 clear 方法
//    	如果你只想获取 key，可以使用 keySet() 方法，然后可以通过 get(key) 获取对应的 value，
//    	如果你只想获取 value，可以使用 values() 方法。
    	for(Integer i : m2.keySet()) {
    		System.out.println("key:"+i+"  value:"+m2.get(i));
    	}
    	for(String i : m2.values()) {
    		System.out.println("value:"+i);
    	}
        //用面向对象的思想将map集合中的键和值映射关系打包为一个对象，就是Map.Entry，将该对象存入Set集合。
        //Map.Entry是一个对象，那么该对象具备的getKey，getValue获得键和值。
    	Map map = new HashMap();
		map.put(1,"Tom");
		map.put(2, "Jerry");

		Set entrys = map.entrySet();

		Iterator  it = entrys.iterator();
		while(it.hasNext()){
		    Map.Entry  entry = (Map.Entry)it.next();
		    System.out.println("键： "+ entry.getKey()+ "  值: "+ entry.getValue());
		}

    	
    }
}

       1、HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

         2、在Map 中插入、删除和定位元素，HashMap 是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。　　

蒟蒻的贤
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值