今天学习了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()的实现。
扫一扫
6553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
