一些注意事项

Iterator 和 Iterable

是 Java 中用于处理集合类型的接口，它们的作用和功能有所不同：

1. Iterator（迭代器）： Iterator 接口提供了一种顺序访问集合元素的方法。它允许您在遍历集合时，通过调用 next() 方法逐个访问集合中的元素，并使用 hasNext() 方法检查是否还有下一个元素可供访问。如果集合支持修改操作，Iterator 还可以使用 remove() 方法删除当前元素。

2. Iterable（可迭代对象）
   可迭代的(自己重写了迭代器的方法,方法体中包含了一个以及封装好的Iterator类)
   ： Iterable 接口定义了一种能够产生 Iterator 实例的方法。它是一个包含 iterator() 方法的接口，当一个类实现了 Iterable 接口时，它意味着该类的实例可以被迭代。通常情况下，可以通过使用 foreach 循环来遍历实现了 Iterable 接口的集合。

简而言之，Iterator 是用于遍历集合的对象，而 Iterable 是用于指示一个对象是否可迭代的接口。通过实现 Iterable 接口并提供 iterator() 方法，可以使得该对象能够被 foreach 循环遍历。

示例代码演示了如何使用 Iterator 和 Iterable：

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

public class IteratorAndIterableExample implements Iterable<Integer> {

    private List<Integer> numbers = new ArrayList<>();

    public IteratorAndIterableExample() {
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
    }

    @Override
    public Iterator<Integer> iterator() {
        return numbers.iterator();
    }

    public static void main(String[] args) {
        IteratorAndIterableExample example = new IteratorAndIterableExample();

        // 使用 Iterator 遍历集合
        Iterator<Integer> iterator = example.iterator();
        while (iterator.hasNext()) {
            Integer number = iterator.next();
            System.out.println(number);
        }

        // 使用 foreach 循环遍历集合
        for (Integer number : example) {
            System.out.println(number);
        }
    }
}



/*   在上面的示例中，IteratorAndIterableExample 类实现了 Iterable 接口，
并提供了 iterator() 方法来获取 Iterator 对象。通过调用 iterator() 方法，
可以获得一个用于遍历集合的 Iterator 对象，
并使用 hasNext() 和 next() 方法逐个访问集合元素。
同时，由于 IteratorAndIterableExample 类实现了 Iterable 接口，
因此可以直接在 foreach 循环中遍历该类的实例。   */

Comparator  ==>java   (scala==> Ordering)比较器
Comparable ==>java   (scala==>Ordered)可比较的

Comparable==>实现compareTo

Comparator ==>实现compare

Comparator 和 Comparable 是 Java 中用于排序对象的两个接口，它们有着相似的作用，但也有一些区别。

1. Comparable（可比较的）： Comparable 接口是一个内部比较器接口，用于实现对象的自然排序。当一个类实现了 Comparable 接口时，它必须实现 compareTo() 方法，该方法定义了对象之间的自然排序规则。通过实现 Comparable 接口，可以让对象具备自我比较和排序的能力。例如，如果要对一个包含数字的列表进行排序，可以实现 Comparable 接口来定义数字之间的比较规则，并使用 Collections.sort() 方法进行排序。

2. Comparator（比较器）： Comparator 接口是一个外部比较器接口，用于实现对象的定制排序。与 Comparable 不同，Comparator 接口允许在需要时提供多种不同的比较规则。它定义了 compare() 方法，该方法接受两个对象作为参数，并根据指定的比较规则返回一个整数值。通过实现 Comparator 接口，可以为任何已经存在的类创建一个单独的比较器类，以便在排序时使用。

简而言之，
Comparable 是一个内部比较器接口，用于实现对象的自然排序；(一般在具体类中使用)
而 Comparator 是一个外部比较器接口，用于实现对象的定制排序。(一般在实现对象后,看具体情况,再重写使用接口,一般都是匿名对象)

示例代码演示了如何使用 Comparable 和 Comparator 接口

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }
}

class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return person1.getName().compareTo(person2.getName());
    }
}

public class  Example {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("Alice", 25));
        personList.add(new Person("Bob", 30));
        personList.add(new Person("Charlie", 20));

        // 使用 Comparable 排序
        Collections.sort(personList);
        System.out.println("按年龄排序：");
        for (Person person : personList) {
            System.out.println(person.getName() + " - " + person.getAge());
        }

        // 使用 Comparator 排序
        Collections.sort(personList, new PersonComparator());
        System.out.println("按姓名排序：");
        for (Person person : personList) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

在上面的示例中，Person 类实现了 Comparable<Person> 接口，并根据年龄实现了 compareTo() 方法。然后，在 main 方法中，通过调用 Collections.sort() 方法，可以对 personList 中的 Person 对象进行排序。首先使用 Comparable 进行排序，按照年龄从小到大进行排序。然后，创建了一个 PersonComparator 类来实现 Comparator<Person> 接口，并根据姓名实现了 compare() 方法。最后，使用 PersonComparator 对象作为参数调用 Collections.sort() 方法，按照姓名进行排序。

通过实现 Comparable 和 Comparator 接口，我们可以实现不同的排序规则，并在需要时对对象进行排序。

Scala中的特性

隐式转换
           隐式转换（Implicit Conversion）是Scala中的一个特性，它允许在需要不同类型的对             象时自动进行类型转换，以使代码更加灵活和简洁。

           隐式类
===>

1. 隐式类必须定义在一个对象、类或特质的内部。
2. 隐式类的构造函数只能有一个参数。
3. 隐式类不能是case class（样例类）。
4. 隐式类的作用域被限制在当前作用域内====>

隐式参数

getOrElse

 不适用Array,需要结合lift方法使用

 List中

 getOrElse适用于Map

 简单来讲,就是给定一个值a
值a=getOtElse中的(n1,n2)a=n1的话,就返回n2,不然就返回n1

flatten   

可以压平
 
1=========>
val ls = List("hello" , "hi" , "heihei" , "tom")
val res2: Seq[Char] = ls.flatten  // 压成单个字符  因为字符串属于序列集合的一种
List(h, e, l, l, o, h, i, h, e, i, h, e, i, t, o, m)


2===========>
 // 压平存储Map集合的list   获取Map中每个元素

 val ls1 = List[Map[String,Int]] (Map[String,Int]("a"->10,"ab"->10,"jim"->100,"cat"->99))
    val flatten: List[(String, Int)] = ls1.flatten
    // List((a,10), (ab,10), (jim,100), (cat,99))
    println(flatten)


val ls1 = List[Map[String,Int]](Map[String,Int]("a"->10,"ab"->10) , Map[String,Int]("jim"->100,"cat"->99))===>另外一种方式

3=======>
val res: List[Int] = List(Array(1,2,3),Array(4,5,6)).flatten
List(1, 2, 3, 4, 5, 6)


不可以压平

1=========>
 Int   数值类型的无法压平
val arr = Array(1,2,345,67,5.23)
//val res1: Array[Nothing] = arr.flatten

2==========>
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
// map无法直接压平
//val flatten: immutable.Iterable[Nothing] = map.flatten



// 错误  注意压平的数据的类型
 val res4 = List(Array(1,2,3),Array("hel",5,6)).flatten 
不可以压平