列表内又嵌套一个列表的话，还能对其进行排序吗，例如[1,2,3,4,[5,6,7]]

Posted 2023-04-12

1、a = [[1,2,3], [4,5,6], [7,8,9]]

b = []

for i in a:

for j in i:

b.append(j)

a = b

2、public class MPSort

public static void main(String[] args)

int[] arr = 2, 4, 1, 5, 6, 7, 3, 8, 9, 0;

sort(arr);

for (int a : arr)

System.out.println(a);

/**

* 

*/

public static void sort(int[] arr)

int temp;

for (int i = 0, j = arr.length; i < j; i++)

for (int x = 0; x < j - i - 1; x++)

if (arr[x] > arr[x + 1])

temp = arr[x];

arr[x] = arr[x + 1];

arr[x + 1] = temp;

扩展资料：

列表控件可使用四种不同视图显示项目。可将项目组成带有或不带有列标头的列，并显示伴随的图标和文本。 

thead、tfoot 以及 tbody 元素使您有能力对表格中的行进行分组。当您创建某个表格时，您也许希望拥有一个标题行，一些带有数据的行，以及位于底部的一个总计行。这种划分使浏览器有能力支持独立于表格标题和页脚的表格正文滚动。当长的表格被打印时，表格的表头和页脚可被打印在包含表格数据的每张页面上。

参考资料来源：百度百科-tbody

参考技术A 伟大的爱因斯坦同志说过：“如果你无法向一个 6 岁小孩解释清楚某问题，那说明你自己都没整明白”。然而，当我向一个 27 岁的朋友解释什么是闭包时，却彻底失败了。

这原本是国外某哥们儿在 Stack Overflow 上对 javascript 闭包所提出的问题。不过既然此问题是在 Stack Overflow 提出的，当然也会有很多高手出来解答，其中有些回答确实是经典，如下面这个：

如果在一个外部函数中再定义一个内部函数，即函数嵌套函数，那么内部函数也可以访问外部函数中的变量：
function foo(x) var tmp = 3; function bar(y) alert(x + y + (++tmp)); bar(10); foo(2); // alert 16 foo(2); // alert 16 foo(2); // alert 16
此段代码可以正确执行，并返回结果：16，因为 bar 能访问外部函数的变量 tmp， 同时也能访问外部函数 foo 的参数 x。但以上示例不是闭包！

要实现闭包的话，需要将内部函数作为外部函数的返回值返回，内部函数在返回前，会将所有已访问过的外部函数中的变量在内存中锁定，也就是说，这些变量将常驻 bar 的内存中，不会被垃圾回收器回收，如下：
function foo(x) var tmp = 3; return function (y) alert(x + y + (++tmp)); var bar = foo(2); // bar 现在是个闭包了 bar(10); // alert 16 bar(10); // alert 17 bar(10); // alert 18
上述代码中，第一次执行 bar 时，仍会返回结果：16，因为 bar 仍然可以访问 x 及 tmp，尽管它已经不直接存在于 foo 的作用域内。那么既然 tmp 被锁定在 bar 的闭包里，那么每次执行 bar 的时候，tmp 都会自增一次，所以第二次和第三次执行 bar 时，分别返回 17 和 18。

此示例中，x 仅仅是个纯粹的数值，当 foo 被调用时，数值 x 就会作为参数被拷贝至 foo 内。

但是 JavaScript 处理对象的时候，使用的总是引用，如果用一个对象作为参数来调用 foo，那么 foo 中传入的实际上是原始对象的引用，所以这个原始对象也相当于被闭包了，如下：
function foo(x) var tmp = 3; return function (y) alert(x + y + tmp++); x.memb = x.memb ? x.memb + 1 : 1; alert(x.memb); var age = new Number(2); var bar = foo(age); // bar 现在是个闭包了 bar(10); // alert 15 1 bar(10); // alert 16 2 bar(10); // alert 17 3
和期望的一样，每次执行 bar(10) 时，不但 tmp 自增了，x.memb 也自增了，因为函数体内的 x 和函数体外的 age 引用的是同一个对象。

via http://stackoverflow.com/questions/111102/how-do-javascript-closures-work

补充：通过以上示例，应该能比较清楚的理解闭包了。如果觉得自己理解了，可以试着猜猜下面这段代码的执行结果：
function foo(x) var tmp = 3; return function (y) alert(x + y + tmp++); x.memb = x.memb ? x.memb + 1 : 1; alert(x.memb); var age = new Number(2); var bar1 = foo(age); // bar1 现在是个闭包了 bar1(10); // alert 15 1 bar1(10); // alert 16 2 bar1(10); // alert 17 3 var bar2 = foo(age); // bar2 现在也是个闭包了 bar2(10); // alert ? ? bar2(10); // alert ? ? bar2(10); // alert ? ? bar1(10); // alert ? ? bar1(10); // alert ? ? bar1(10); // alert ? ?
实际使用的时候，闭包可以创建出非常优雅的设计，允许对funarg上定义的多种计算方式进行定制。如下就是数组排序的例子，它接受一个排序条件函数作为参数：
[1, 2, 3].sort(function (a, b) ... // 排序条件 );
同样的例子还有，数组的map方法是根据函数中定义的条件将原数组映射到一个新的数组中：
[1, 2, 3].map(function (element) return element * 2; ); // [2, 4, 6]
使用函数式参数，可以很方便的实现一个搜索方法，并且可以支持无限制的搜索条件：
someCollection.find(function (element) return element.someProperty == 'searchCondition'; );
还有应用函数，比如常见的forEach方法，将函数应用到每个数组元素：
[1, 2, 3].forEach(function (element) if (element % 2 != 0) alert(element); ); // 1, 3
顺便提下，函数对象的 apply 和 call方法，在函数式编程中也可以用作应用函数。 这里，我们将它们看作是应用函数 —— 应用到参数中的函数（在apply中是参数列表，在call中是独立的参数）：
(function () alert([].join.call(arguments, ';')); // 1;2;3 ).apply(this, [1, 2, 3]);
闭包还有另外一个非常重要的应用 —— 延迟调用：
var a = 10; setTimeout(function () alert(a); // 10, after one second , 1000); 还有回调函数： //... var x = 10; // only for example xmlHttpRequestObject.onreadystatechange = function () // 当数据就绪的时候，才会调用; // 这里，不论是在哪个上下文中创建 // 此时变量“x”的值已经存在了 alert(x); // 10 ; //...
还可以创建封装的作用域来隐藏辅助对象：
var foo = ; // 初始化 (function (object) var x = 10; object.getX = function _getX() return x; ; )(foo); alert(foo.getX()); // 获得闭包 "x" – 10

以特定顺序对（数组）列表进行排序

【中文标题】以特定顺序对（数组）列表进行排序

【英文标题】：Sort an (Array)List with a specific order

【发布时间】：2014-01-01 05:55:05

【问题描述】：

我有一个对象列表，我想按照定义的顺序对其进行排序。 例如。我有一个带有String color 字段的对象。我想在颜色字段上对我的列表进行排序，以便它总是先是白色，然后是蓝色，然后是黄色，然后是所有其他（如果可能的话，按顺序排列，但不是必需的）：

Before sorting:         After sorting:
orange                  white
white                   blue
green                   yellow
brown                   orange
yellow                  black
black                   brown
...                     ...

有没有（简单的）方法可以做到这一点？

编辑：

我必须添加更多复杂功能... 如果可以有更多具有相同名称/基数的颜色怎么办？例如。 whiteX, whiteY, whiteZ, blueA, blueB, ... 所有的白人必须先于所有的蓝色，然后是所有的黄色，然后是所有其他人。仍然可以用比较器解决这个问题吗？ （我无法想象如何......）

【参考方案1】：

这是另一个选择：

Map<Integer, String> tree = new TreeMap<Integer, String>();
    List<String> listOrdre = Arrays.asList("white", "blue", "yellow", "orange", "black", "brown");
    List<String>   myList  = Arrays.asList("orange", "white", "brown", "yellow", "black");

    for (String code : myList) 
        tree.put(listOrdre.indexOf(code), code);
    

    System.out.println(tree.values()); // -> [white, yellow, orange, black, brown]

【参考方案2】：

是的，您可以创建一个Comparator 来创建您的排序策略，或者定义实现Comparable 的类的自然顺序

附注：

强烈建议，但不严格要求 (x.compareTo(y)==0) == (x.equals(y))

使用比较器的示例：

class MyClass 

private Color color;
private String someOtherProperty;
public static final Comparator<MyClass> COLOR_COMPARATOR = new MyComparator();

//getter and setter

static class MyComparator implements Comparator<MyClass>

            @Override
            public int compare(MyClass o1, MyClass o2) 
                // here you do your business logic, when you say where a color is greater than other
                

在客户端代码中。

例子：

List<MyClass> list = new ArrayList<>();
//fill array with values
Collections.sort(list, MyClass.COLOR_COMPARATOR );

阅读更多：Collections#sort(..)

如果您想定义类的自然排序，只需定义

public class MyClass implements Comparable<MyClass>

        @Override
        public int compareTo(MyClass o) 
           // do business logic here
        

在客户端代码中：

   Collections.sort(myList); // where myList is List<MyClass>

【讨论】：

可能值得一提Collections.sort

【参考方案3】：

您可以使用comparator。

您可以做的另一件事是为数字设置一些值（比如 1 到 n ）。例如，在您的情况下，给白色 1，给蓝色 2，给黄色 3。现在对这些数字进行排序。

【参考方案4】：

另一种解决方案是在比较器中使用枚举，因为枚举已经定义了一个索引（序数）。

首先，按照您希望排序的顺序使用您的值创建一个枚举。

enum class MyColour 
    WHITE,
    BLUE,
    YELLOW,
    ORANGE,
    BLACK,
    BROWN

对于每个对象，您可以使用Mycolour.valueOf("WHITE") 获取枚举值。注意：这是区分大小写的。

接下来，您可以简单地使用比较器。

val sortedList = list.sortedBy  it.colour  // colour being the enum value we defined.