插入排序,是循环遍历贰个冬季数组(例如有11个因素),把遍历出来的数值(第i个要素)插入到曾经排过种种的数组(那个不变数组有十-i个成分)中。

1、集合遍历

1、for 循环

java-Collection,List简单使用与方式/(集合使用-中),

一.一集结只存放引用类型的因素并且集合存放的时成分的引用(地址)
一.2新循环遍历集合
Collection c = new ArrayList();
c.add(“one”);
c.add(“two”);
c.add(“three”);
c.add(“four”);
/*
*iOS学习16之OC集合遍历和数组排序,List简单使用与措施。 新循环不是新的语法,jvm并不认同新循环。
*
新循环是编写翻译器承认的,当编写翻译器发今后使用新循环遍历集合时,会将代码改变为运用迭代器遍历,所以利用新循环遍历集合的进程中是不可能透过集合的格局增加和删除成分的。
*
*金沙注册送58 ,/
for (Object object : c) {
String str = (String)object;
System.out.println(str);
}
壹.3会晤的操作
boolean addAll(collection c) 将给定的汇集中的成分存入到目前集合中
当前集合成分产生了转变则赶回true
boolean containsAll(Collection c)
判断当前聚集是不是带有给定集合中的富有因素
boolean removeAll(Collection c) 删除当前集结中与给定集合的平等成分
一.八回历集合–集合提供联合的遍历成分的主意:迭代器格局
集结提供了用于获取遍历当前集合成分的措施:
java.util.Iterator
Iteartor
iterator()迭代器的接口,规定了遍历集合的法子,遵从的情势为:问,取,删的步骤,当中删除成分不是必须操作。区别的集聚完结类都提供了三个足以遍历本身的迭代器完结类。大家无需记住它们的名字,当他们的Iterator看待即可。
boolean hasNext()判断集合是还是不是还有成分得以遍历
E next() 取出集合下1个足以遍历的因素
在应用迭代器遍历集合成分的长河中,不能够透过聚合的秘诀增加和删除成分否则会掀起迭代器遍历集合的丰富,不过迭代器的remove能去除通过next方法取出的因素
一.5新循环–新循环又叫做:增强for循环,for
each,新循环的成效是用来遍历集合或数组—–新循环是JDK一.5之后推出的1个新特性
选取新循环遍历集合:新循环并非新的语法,JVM并不承认新循环。新循环是编写翻译器认同的,当编写翻译器发以后应用新循环遍历集合时,会将代码改变为运用迭代器遍历。所以选择新循环遍历集合的经过中是不能够通过聚合的法子增加和删除成分的。假如在新循环中删去成分会抛出至极。
一.陆泛型–壹.五过后推出的叁个表征,泛型是编写翻译器认同泛型的其实类型是Object,在行使的时候编写翻译器会进展检查或活动造型。当对泛型变量赋值时,编写翻译器检查是还是不是符合项目须要获取泛型值时,编写翻译器会补充自动造型的代码。不点名泛型则暗许认为object。泛型用来鲜明集合中的成分类型
1.7List_get_set–java.util.List
List是Collection的子类型接口。是可重复集,并且有序,提供了一套能够依据下标操作成分的不二等秘书籍。
常用落成类:
java.util.ArrayList:数组完结,查询功效高
java.util.LinkedList:链表达成,增加和删除成分功用高越发是前后增加和删除成分。
E get(int index) 将内定下标所对应的因素再次来到
E set(int index,E e)
将给定成分替换集合中内定地方的要素并将被替换元素重临。
1.8List_add_remove:List提供了1对重载的add,remove方法也足以经过下标操作成分删除方法会重临一个刨除的因素。
一.玖收获List子集:List<E> subList(int startindex,int endindex)
截取集合中钦命地点的元素,并回到截取的因素;操作获取的子集的时候就特出操作原有集合
①.10汇聚转换为数组 —Collection中提供了将方今聚集转换为二个数组的章程
E[] array= c.toArray(new
E[c.size()]);将聚集转换为数组,传1个泛型数组并设置长度,如果设置长度不够也会回去二个正好和要素相等的数组,要是参数长度超过原有数组,则赶回输入长度的数组,未有成分的地点为null。
一.1一数组更换为汇集—List<String> list =
Arrays.asList(array);将数组转化为汇集,操作再次回到后的成团等于操作原来的数组,并且不可能增加和删除成分,假若想增欧成分须要新建二个数组将回来数组的值传入并操作。
List<String> list1 = new
ArrayList<String>(list);这么些办法能够在创建新数组的还要将原有数组的因素添加进去。

 

自身是初大方,如有更新倒霉的,欢迎那位大神建议,谢谢大家!

更多优异今后更新,转发注脚!

1.一成团只存放引用类型的要素并且集合存放的时成分的引用(地址)
一.贰新循环遍历集合…

用3个 数组 举个例证:

 1> 遍历

  集合(Collection):OC中提供的容器类:数组,字典,集合。

  遍历:对聚集七月素依次取出的过称叫做遍历。

  二种办法:一 for循环遍历; 贰 NSEnumerator遍历; 三 for…in遍历

let arr = [1,2,3];
for (let i=0; i<arr.length; i++){
 console.log(i,arr[i])
}
// 0 1
// 1 2
// 2 3

起初数组:一, 8九, 4, 3④, 5陆, 40, 5九,
60, 3玖, 一, 40, 90, 4八 

 二> for循环遍历

for 循环是 Js 中最常用的三个巡回工具,平常用来数组的循环遍历。

先是次巡回(i=0):一, 89, 肆, 3四, 5陆, 40, 5九, 60, 3九, 一, 40, 90,
4八 

  一 数组遍历

   原理:通过for循环的循环变量用作数组成分下标来收获不一样下标的成分。

   循环次数就是数组成分的个数。

1 // 数组
2 for (int i = 0; i < arr.count; i++) {
3     NSLog(@"%@", arr[i]);
4 }

2、for in 循环

其次次巡回(i=一):  一, 8玖, 4, 3四, 5陆, 40, 5九, 60, 3九, 一, 40, 90,
4捌 

  2 字典遍历

   原理:先取得字典中存有的key,存款和储蓄到数组中,遍历数组依次取出每一个key,然后依照key从字典中取出对应的value

   循环次数正是字典成分的个数。

1         // 字典
2         // 获取字典中所有的key值
3         NSArray *allKey = [dict allKeys];
4         // 遍历key值数组,访问对应的object值
5         for (int i = 0; i < allKey.count; i++) {
6             NSString *key = allKey[i];
7             NSLog(@"%@", [dict objectForKey:key]);
8         }
let obj = {name:'zhou',age:'**'}
for(let i in obj){
 console.log(i,obj[i])
}
// name zhou
// age **

其1次巡回(i=二):  一, 肆, 8九,
3四, 5陆, 40, 59, 60, 39, 一, 40, 90, 4八 

  3 集合遍历

   原理:用集合的allObjects属性先取到聚集的享有因素存款和储蓄到数组中,再通过for循环的循环变量用作下标来取到每一个成分。

1         // 集合
2         // 取出集合中的所有元素放到数组中
3         NSArray *setArray = [set allObjects];
4         for (int i = 0; i < setArray.count; i++) {
5             NSLog(@"%@", setArray[i]);
6         }

for in 循环主要用以遍历普通对象,i 代表对象的 key 值,obj[i]
代表对应的
value,当用它来遍历数组时候,多数景况下也能达到规定的标准相同的功力,不过你绝不那样做,那是有高风险的,因为
i
输出为字符串格局,而不是数组要求的数字下标,那表示在好几处境下,会发出字符串运算,导致数据失实,比如:’52’+1= ’52壹’ 而不是我们供给的 5三。

第九遍巡回(i=三):一, 四, 34,
89, 5陆, 40, 5玖, 60, 3玖, 1, 40, 90,
4捌 

 3> NSEnumerator

其它 for in 循环的时候,不仅遍历自个儿的质量,还会找到 prototype
上去,所以最佳在循环体内加三个判断,就用
obj[i].hasOwnProperty(i),那样就防止遍历出太多不必要的质量。

… …

  ① 概述 

   枚举器,遍历集合中的成分。

   依附于集合类(NSArray,NSSet,NSDictionary),未有用来创建实例的接口。

   NSEnumerator的 nextObject
方法能够遍历每种集合成分,停止再次来到 nil ,通过与 while
结合使用可遍历集合中保有因素。

   对可变集合(数组,字典,集合)举行枚举操作时,不可能由此丰硕或删除对象那类形式来改变集合容器的成分个数。

3、while 循环

第13次循环(i=12)(结束):1, 1,
4, 34, 39,
40, 40, 48,
56, 59, 60,
89, 90

  贰 数组遍历

   正序(objectEnumerator)

1         // 数组(正序)
2         // 创建正序的枚举器对象
3         NSEnumerator *arrayEnum1 = [arr objectEnumerator];
4         id value1 = nil;
5         // 判断value部位空打印数据
6         while ((value1 = [arrayEnum1 nextObject])) {
7             NSLog(@"%@", value1);
8         }    

   倒序(reverseObjectEnumerator)

1         // 数组(倒序)
2         // 创建倒序的枚举器对象
3         NSEnumerator *arrayEnum2 = [arr reverseObjectEnumerator];
4         id value2 = nil;
5         while ((value2 = [arrayEnum2 nextObject])) {
6             NSLog(@"%@", value2);
7         }

  注:枚举器的nextObject方法只好取出三个对象,所以必要和while循环结合把装有因素依次取出。

  三 字典遍历

1         // 字典
2         // 遍历到的是字典中的value值
3         NSEnumerator *dictEnum = [dict objectEnumerator];
4         id value3 = nil;
5         while ((value3 = [dictEnum nextObject])) {
6             NSLog(@"%@", value3);
7         }

  注:字典中存放的数额是冬季的,没有反向枚举的定义。

  肆 集合遍历

1         // 集合
2         NSEnumerator *setEnum = [set objectEnumerator];
3         id value4 = nil;
4         while ((value4 = [setEnum nextObject])) {
5             NSLog(@"%@", value4);
6         }

  注:集合中存放的数目是冬辰的,未有反向枚举的概念。

壹样的遍历 cars 数组,先用 for 循环方法

int[] sort = new int[13] { 1, 4, 89, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 };  // 输入一个数组
for (int i = 0; i < sort.Length; i++)
    {
         int temp = sort[i];   // 临时存储第i个数的值
         int j = i;

         for (; j > 0 && temp < sort[j - 1]; j--)  // 遍历有j 个数的有序数组(j从0开始),当 temp 临时值小于sort[j-1](初始是,有j个数,j-1 为最后一个数)时,把当前第(j-1)位上的数向后移一位(j)
              {
                  sort[j] = sort[j - 1];

              }
                sort[j] = temp;  // 退出循环后,把temp 放到 第j 个位置上(j 是经过循环处理后得到的)

    }
for (int i = 0; i < sort.Length; i++) // 输出
    {
         Console.Write(sort[i] + " ");
    }

 4> for…in 遍历

let cars=["BMW","Volvo","Saab","Ford"];
let i=0;
for (;cars[i];)
{
console.log(cars[i])
i++;
};
// BMW
// Volvo
// Saab
// Ford

 

  ① 概述

   for…in:连忙枚举,是在NSEnumerator的根基上包裹的愈加便利的火速的遍历集合成分的艺术。

   格式:for (集合中目的的类别 * 成分名 in 被遍历的会合) {

      语句;

       }

   对可变集合(数组,字典,集合)举办高效枚举操作时,无法经过抬高或删除对象那类形式来改变集合容器的因素个数。

  二 数组遍历

1         // 数组
2         for (id value in arr) {
3             NSLog(@"%@", value);
4         }

  三 字典遍历

1         // 字典 遍历的是字典的key
2         for (id value in dict) {
3             NSLog(@"%@", dict[value]);
4         }

  肆 集合遍历

1         // 集合
2         for (id value in set) {
3             NSLog(@"%@", value);
4         }

下一场是 while 循环方法

二、数组排序

 数组是一成不变容器,因而集合中唯有数组才能排序。

cars=["BMW","Volvo","Saab","Ford"];
var i=0;
while (cars[i])
{
console.log(cars[i] + "<br>")
i++;
};

 一> NSSortDescriptor(排序描述符)概述

  该类能够有利于的落实对数组中的对象开始展览升序或然降序的排序。

  它能够把成分的某部属性作为key进行升序或降序的排序,种种NSSortDescriptor对象正是2个排序条件。

大家发现,它们能够兑现均等的效果,事实上它们底层的拍卖是同等的,不过 for
循环能够把定义、条件判断、自增自减操作放到三个尺码里实施,代码看起来方便1些,仅此而已。

 贰> NSSortDescriptor成立方法

  开端化方法

  - (instancetype)initWithKey:(NSString
*)key ascending:(BOOL)ascending;

  key:根据数组中指标的哪些属性进行排序,假若数组中存放的是能够一向排序的指标(比如:字符串),直接使
@”self” 可能 nil 即可;就算存放的是自定义类的对象,使用想要实行排序的属性名即可(比如:想规行矩步Person类的name举办排序,
使用 @”name” 作为参数)。
       ascending:排序的标志,是升序依然降序。
YES – 升序, NO –
降序。

NSSortDescriptor创建

1 NSSortDescriptor *sortDes1 = [[NSSortDescriptor alloc] initWithKey:@"self" ascending:YES]; // 升序
2 NSSortDescriptor *sortDes2 = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:NO]; // 降序

4、do while 循环

  一 不可变数组

排序

1 // 基本数据类型不可变数组
2 array = [array sortedArrayUsingDescriptors:@[sortDes1]];
3 NSLog(@"%@", array);
4 // 自定义对象不可变数组
5 // 按照名字排序
6 personArray = [personArray sortedArrayUsingDescriptors:@[sortDes2]];
7 NSLog(@"%@", personArray);

 二 可变数组

排序

1 // 基本类型可变数组
2 [mArray sortUsingDescriptors:@[sortDes1]];
3 NSLog(@"%@", mArray);
4 // 自定义对象可变数组
5 // 按照名字排序
6 [personMArray sortUsingDescriptors:@[sortDes2]];
7 NSLog(@"%@", personMArray);
let i = 3;
do{
 console.log(i)
 i--;
}
while(i>0)
// 3
// 2
// 1

 三> 使用数组中 多少个因素相比较的措施名 举办排序

do while 循环是 while
循环的3个变体,它首先实施一回操作,然后才举办标准化判断,是 true
的话再继续执行操作,是 false 的话循环甘休。

  1 不可变数组排序:(排序结果生成新数组, 原数组无更改)

   -
(NSArray
*)sortedArrayUsingSelector:(SEL)comparator;

   注:SEL类型的参数comparator:供给传入一个回去结果是NSComparisonResult的格局名。

1 // 不可变数组(基本数据类型)
2 array = [array sortedArrayUsingSelector:@selector(compare:)];
3 NSLog(@"%@", array);
4 // 不可变的数组(自定义类型的对象)
5 // 按照名字排序
6 personArray = [personArray sortedArrayUsingSelector:@selector(compareByName:)]; // compareByName为Person类中自定义的方法
7 NSLog(@"%@", personArray);

5、Array forEach 循环

  贰 可变数组排序:(直接对原数组操作,无新数组变化)

   - (void)sortUsingSelector:(SEL)comparator;

   注:SEL类型的参数comparator:必要传入三个返回结果是NSComparisionResult的函数

1 // 可变数组(基本数据类型)
2 [mArray sortUsingSelector:@selector(compare:)];
3 NSLog(@"%@", mArray);
4 // 可变的数组(自定义类型的对象)
5 // 按照名字排序
6 [personMArray sortUsingSelector:@selector(compareByName:)];
7 NSLog(@"%@", personMArray);

  Person类中compareByName方法:

1          // 比较方法的声明
2          - (NSComparisonResult)compareByName:(Person *)anotherPerson;
3          // 比较方法的实现
4          - (NSComparisonResult)compareByName:(Person *)anotherPerson {
5          return [self.name compare:anotherPerson.name];
6          }

 

let arr = [1,2,3];
arr.forEach(function(i,index){
 console.log(i,index)
})
// 1 0
// 2 1
// 3 2

forEach循环,循环数组中每1个要素并动用操作, 没有重回值,
能够不用知道数高管度,他有四个参数,唯有首先个是需要的,代表当前下标下的
value。

其它请留意,forEach 循环在装有因素调用达成从前是无法止住的,它未有 break
语句,若是您无法不要甘休,能够品味 try catch
语句,正是在要强制退出的时候,抛出多个 error 给 catch 捕捉到,然后在
catch 里面
return,那样就能暂停循环了,如若你常常用那个措施,最棒自定义1个这么的
forEach 函数在你的Curry。

6、Array map()方法

let arr = [1,2,3];
let tt = arr.map(function(i){
 console.log(i)
 return i*2;
})
// [2,4,6]

map()
方法重临二个新数组,数组中的成分为原始数组成分调用函数处理后的值。
瞩目:map 和 forEach 方法都以只可以用来遍历数组,无法用来遍历普通对象。

7、Array filter() 方法

let arr = [1,2,3];
let tt = arr.filter(function(i){
 return i>1;
})
// [2,3]

filter 方法是 Array
对象放置方法,它会回去经过过滤的元素,不更改原先的数组。

8、Array some() 方法

let arr = [1,2,3];
let tt = arr.some(function(i){
 return i>1;
})
// true

some() 方法用于检查测试数组中的元素是或不是知足钦点条件(函数提供),重回 boolean
值,不更改原数组。

9、Array every() 方法

let arr = [1,2,3];
let tt = arr.some(function(i){
 return i>1;
})
// 检测数组中元素是否都大于1
// false

every() 方法用于检查实验数组全体因素是或不是都适合内定条件(通过函数提供),再次回到boolean 值,不改动原数组。

10、Array reduce()方法

let arr = [1,2,3];
let ad = arr.reduce(function(i,j){
 return i+j;
})
// 6

reduce()
方法接收三个函数作为累加器,数组中的种种值(从左到右)发轫减小,最后总结为1个值。

11、Array reduceRight()方法

let arr = [1,2,3];
let ad = arr.reduceRight(function(i,j){
 return i+j;
})
// 6

reduceRight()方法,和 reduce()
功效是千篇一律的,它是从数组的末尾处向前初始盘算。

12、for of 循环

let arr = ['name','age'];
for(let i of arr){
 console.log(i)
}
// name
// age

for of 循环是 Es陆 中新增的话语,用来替代 for in 和 forEach,它同意你遍历
Arrays(数组), Strings(字符串), Maps(映射),
Sets(集合)等可迭代(Iterable data)的数据结构,注意它的兼容性。

总结

如上正是自己总计的 Js 中常见的巡回遍历方法,随着 Es6标准的包容性越来越好,小编发觉许多兑现方案慢慢都不再须求了,比如
let、const 取代var 后,在好几景况下的闭包函数也就不设有了。

您也许感兴趣的文章:

  • js 达成获取name
    相同的页面成分并循环遍历的主意
  • JavaScript中动用for循环遍历数组
  • Javascript数组循环遍历之forEach详解
  • JS不难循环遍历json数组的不贰秘籍
  • JavaScript中循环遍历Array与Map的法子小结
  • JS
    使用for循环遍历子节点查找元素
  • JS使用for循环遍历Table的有着单元格内容
  • JS数组的遍历方式for循环与for…in
  • js数组循环遍历数组内全部因素的形式
  • javascript
    forEach通用循环遍历方法

相关文章

网站地图xml地图