Java中的复合数据类型

public class MyString {
    public static void main(String[] args) {
        String s1="字符串";
        String s2="字符串";
        String s3=s1;
        System.out.println(s1==s2);     // s1、s2字符串内容相同，指向相同的内存空间，输出：true
        System.out.println(s1==s3);     // 修改之前s1与s3相同，输出：true
        s1="修改字符串";
        System.out.println(s1==s3);     // 修改之后s1指向新的内存空间，与s3不同，输出：false
    }
}

str.length()    //返回当前字符串的长度
str.indexOf(int ch)    //查找ch字符在该字符串中第一次出现的位置，若无返回-1
str.indexOf(subStr)    //查找str子字符串在该字符串中第一次出现的位罝
str.lastIndexOf(ch)    //查找ch字符在该字符串中最后一次出现的位置
str.lastlndexOf(subStr)查找St子字符串在该字符串中最后一次出现的位置
str.substring(beginlndex)    //获取从beginlndex位置幵始到结朿的子字符串
str.substring(beginlndex, endlndex)    //获取从beginlndex位置幵始到endlndex位M的子字符串
str.trim()        //返回去除了前后空格的字符串
str.equals(obj)        //将该字符串与指定对象比较，返回true或false
str.toLowerCase()        //将字符串转换为小写
str.toUpperCase()        //将字符串转换为大写
str.charAt(int index)    //获取字符串中指定位置的字符
str.setCharAt(i,c)    //设置某个位置的字符串
str.split(String regex, int limit)        //将字符串分割为子字符串，返回字符串数组
str.concat(str2)        //将str2拼接到末尾
str.getBytes()        /将该字符串转换为byte数组
str.toCharArray()        //转化为字符数组

public class MyString {
    public static void main(String[] args) {
        StringBuilder s4=new StringBuilder("初始字符串");
        StringBuilder s5=s4;
        s4.replace(0,10,"修改后的字符串");
        System.out.println(s4);
        System.out.println(s4==s5);     // 修改后仍然指向同一块内存，因此输出：true
    }
}

char[] arr={'a', 'd', 'e'};
String s=String.valueOf(arr);

                // 定义int类型变量，值为86
		int score1 = 86;       
		// 使用int创建Integer包装类对象，手动装箱
		Integer score2=new Integer(score1);  
                Integer score2=score1;    //自动装箱      
		// 将Integer包装类转换为double类型
		double score3=score2.doubleValue();        
		// 将Integer包装类转换为float类型
		float score4=score2.floatValue();        
		// 将Integer包装类转换为int类型，手动拆箱
		int score5 =score2.intValue();	
                int score5 = score2        // 自动拆箱	
		// 将字符串转为int
		int score6 = Integer.parseInt("666");

int minNum=Math.min(2, 3);    //获取最小值
int maxNum=Math.max(2, 3);    //获取最大值
 
long round=Math.round(3.1415);      //四舍五入
double floor=Math.floor(3.1415);    //向下取整
double ceil=Math.ceil(3.1415);      //向上取整
double random=Math.random();        //取[0,1)之间的随机数

public void addCourse(){
    Course c1=new Course(1,"数据结构");
    Course c2=new Course(2,"操作系统");
    Course[] cArr={new Course(3,"组成原理"),new Course(4,"计算机网络")};
 
    courseList.add(c1);                         // 向数组列表中添加对象
    courseList.add(0,c2);                 // 向指定位置添加对象
    courseList.addAll(Arrays.asList(cArr));     // 向列表中添加子列表，前加数字表示插入位置
    Course tmp=(Course)courseList.get(0);       // 从列表中取出对象
    Course[] courseArr=courseList.toArray(new Course[courseList.size()]);    // 转换为特定类型的数组
}

int[] nums=new int[]{3,1,5,8};
//arr转list
List<Integer> numList = Arrays.stream(nums).boxed().collect(Collectors.toList());
//list转arr
int[] arr = numList.stream().mapToInt(Integer::valueOf).toArray();

    public void showCourse(){
        int listLength=courseList.size();           // 获取列表长度
        for (int i=0;i<listLength;i++) {
            Course c=(Course)courseList.get(i);     // 获取列表第i个元素
            System.out.println(c.name);
        }
    }
 
    public void iteratorCourse(){
        Iterator it=courseList.iterator();          // 获取迭代器
        while (it.hasNext()){                       // 如果仍有下一个元素
            Course c=(Course)it.next();             // 取出下一个元素
            System.out.println(c.name);
        }
    }

    public void modifyCourse(){
        courseList.set(2,new Course(5,"离散数学"));     // 修改2位置上的对象
    }
 
    public void removeCourse(){
        courseList.remove(3);               // 删除3位置上的对象
        Course c1= (Course) courseList.get(1);
        Course c2=(Course) courseList.get(2);
        courseList.remove(c1);                      // 删除指定对象
        Course[] cArr={c1,c2};
        courseList.removeAll(Arrays.asList(cArr));  // 删除courseList中所包含的cArr的元素
    }

    // 重写Course类的equals()方法
    public boolean equals(Object o) {
        if (this == o) return true;     // 如果两个对象的地址相同，肯定相同
        if (!(o instanceof Course)) return false;
        Course course = (Course) o;
        return id == course.id &&       // 判断两个Course对象的id和name相同
                name.equals(course.name);
    }
 
    // 在CourseList中调用contains()判读是否包含某个对象
    public void containCourse(){
        Course nc=new Course(5,"数据结构");
        if(courseList.contains(nc)) {                     // 判断List中是否包含Course对象nc
            int index = courseList.indexOf(nc);           // 获取元素在List中的位置
            System.out.println("列表中包含该课程，位置：" + index);
        }
    }

    // 创建元素类型为Course的列表
    public List<Course> courseList=new ArrayList<Course>(); 
    public void addCourse(){
        Course c=new Course(6,"数据结构");
        courseList.add(c);
//        courseList.add("字符串");    // 尝试向列表中添加非Course类型的对象，报错
        Course c2=courseList.get(0);        // 可以直接取出为Course类型对象
        System.out.println(c2.name);
    }

public class Student implements Comparable<Student> {   // 定义Student类实现Comparable接口
    public String name;
    public int id; 
    public Student(int id, String name) {
        this.name = name;
        this.id = id;
    }
 
    @Override
    public int compareTo(Student o) {        // 实现接口的方法，根据id大小对学生进行比较
        if (this.id>o.id){          // 如果大于o返回1
            return 1;
        }else if (this.id<o.id){    // 小于返回-1
            return -1;
        }else {                     // 等于返回0
            return 0;
        }
    }
}
 
public class ListSort {
    public List<Student> studentList=new ArrayList<Student>();    // 学生列表 
    public void sortStudent(){
        Student s1=new Student(1011,"小明");
        Student s2=new Student(1005,"小赵");
        Student s3=new Student(1021,"小钱");
        Student[] sArr={s1,s2,s3};
        studentList.addAll(Arrays.asList(sArr));
        Collections.sort(studentList);                // 调用方法对学生列表进行排序
        for (Student s:studentList) {
            System.out.println(s.id+":"+s.name);
        }
    }
}

// 自定义比较器类来实现两个Student对象的比较
public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        if (o1.id>o2.id){          // 如果大于o返回1
            return 1;
        }else if (o1.id<o2.id){    // 小于返回-1
            return -1;
        }else {                     // 等于返回0
            return 0;
        }
    }
} 
// 调用sort()方法时传入比较器
Collections.sort(studentList,new StudentComparator());

public class Student {
    public String name;
    public int id;
    public Set<Course> courses;     // 用set保存学生所选课程 
    public Student(int id, String name) {
        this.name = name;
        this.id = id;
        this.courses=new HashSet<Course>();     //创建Hash集
    }
 
    public static void main(String[] args){
        Course c=new Course(1,"数据结构");
        Student s=new Student(101,"小明");     
        s.courses.add(c);               // 向集中添加对象
        for (Course course:s.courses) {         // 遍历集
            System.out.println(course.name);
        }
    }
}

    // 创建存储学生类的哈希Map
    public Map<Integer,String> studentMap=new HashMap<Integer, String>(); 
    public void addStudent(){
        Scanner input=new Scanner(System.in);
        System.out.print("请输入学生ID：");
        int studentID=input.nextInt();
        String s=studentMap.get(studentID);        // 根据key值获取对应的value
        if (s!=null){                              // 如果s不为空说明该key已经存在
            System.out.println("该学生ID已存在！");
        }else {
            System.out.print("请输入姓名：");
            String name=input.next();
            studentMap.put(studentID,name);     // 将<ID,name>键值对添加到Map中
        }
    }
 
    public void showStudent(){            //通过foreach遍历HashMap
        // 获取Map的键值对Entry并对其泛型进行定义
        Set<Map.Entry<Integer,String>> entrySet=studentMap.entrySet();
        for(Map.Entry<Integer,String> entry:entrySet){
            int key= entry.geTKEy();                    // 从Entry中获取key
            String name=entry.getValue();               // 从Entry中获取value
            System.out.println(key+":"+name);
        }
    }
 
    public void showStudent2(){            //通过迭代器遍历HashMap
    　　Iterator iter = studentMap.entrySet().iterator();
　　    while (iter.hasNext()) {
　　        Map.Entry entry = (Map.Entry) iter.next();
　　        Int key= entry.getKey();
　　        String name = entry.getValue();
            System.out.println(key+":"+name);
        }
　　}

        Stack<Integer> st = new Stack<>();      //新建栈
        st.push(3);
        int peek=st.peek();     //获取栈顶元素
        System.out.println(peek);
        int pop=st.pop();       //弹出栈顶元素
        System.out.println(pop);
        System.out.println(st.empty());     //判断栈是否为空

        Queue<Integer> queue = new LinkedList<>();    //创建并初始化队列
        queue.offer(1);     //元素入队
        queue.offer(3);
        queue.offer(5);
        
        for(int num:queue)      //遍历队列
            System.out.println(num);
        int pNum=queue.peek()    //获取第一个元素
        int qNum=queue.poll();  //元素出队
        System.out.println(qNum);