iOS学习1陆之OC会集遍历和数组排序,中的1贰种循环遍历方法

插入排序,是循环遍历二个冬日数组(比方有1一个因素),把遍历出来的数值(第i个成分)插入到曾经排过各类的数组(那几个不改变数组有拾-i个成分)中。

1、集结遍历

1、for 循环

iOS学习1陆之OC会集遍历和数组排序,中的1贰种循环遍历方法。java-Collection,List轻巧使用与措施/(会集使用-中),

壹.一集中只存放引用类型的因素并且集合存放的时成分的引用(地址)
一.2新循环遍历集结
Collection c = new ArrayList();
c.add(“one”);
c.add(“two”);
c.add(“three”);
c.add(“four”);
/*
* 新循环不是新的语法,jvm并不承认新循环。
*
新循环是编写翻译器认同的,当编译器开采在行使新循环遍历集合时,会将代码改变为使用迭代器遍历,所以使用新循环遍历群集的经过中是不能够经过集结的章程增加和删除成分的。
*
*/
for (Object object : c) {
String str = (String)object;
System.out.println(str);
}
一.三凑合的操作
boolean addAll(collection c) 将给定的会见中的成分存入到当下聚聚集当前集结元素爆发了变通则赶回true
boolean containsAll(Collection c)
剖断当前集中是不是带有给定集结中的有所因素
boolean removeAll(Collection c) 删除当前聚集中与给定集合的如出一辙成分
一.七回历群集–集结提供联合的遍历成分的不二等秘书籍:迭代器形式
聚焦提供了用于获取遍历当前会集元素的法子:
java.util.Iterator
Iteartor
iterator()迭代器的接口,规定了遍历集结的艺术,遵循的方式为:问,取,删的步调,个中删除成分不是必须操作。差别的群集落成类都提供了三个能够遍历本身的迭代器落成类。大家没有须要记住它们的名字,当他们的Iterator对待就可以。
boolean hasNext()决断集结是还是不是还有成分得以遍历
E next() 抽取集结下多少个足以遍历的因素
在采用迭代器遍历集结成分的长河中,无法经过集合的方法增删成分不然会引发迭代器遍历集合的丰裕,可是迭代器的remove能去除通过next方法收取的要素
一.五新循环–新循环又称为:加强for循环,for
each,新循环的功力是用来遍历集合或数组—–新循环是JDK1.5今后推出的三个新特点
采纳新循环遍历会集:新循环并非新的语法,JVM并不认同新循环。新循环是编写翻译器承认的,当编写翻译器开掘在应用新循环遍历群集时,会将代码改换为使用迭代器遍历。所以使用新循环遍历集结的历程中是无法经过群集的办法增加和删除成分的。要是在新循环中剔除成分会抛出十二分。
1.陆泛型–一.伍从此推出的三个特色,泛型是编写翻译器认同泛型的骨子里类型是Object,在应用的时候编写翻译器会开始展览反省或自行造型。当对泛型变量赋值时,编写翻译器检查是还是不是吻合项目供给得到泛型值时,编译器会补充自动造型的代码。不钦定泛型则私下认可认为object。泛型用来规定聚积中的成分类型
1.7List_get_set–java.util.List
List是Collection的子类型接口。是可重复集,并且稳步,提供了壹套能够遵照下标操作成分的不2法门。
常用完成类:
java.util.ArrayList:数组完毕,查询效用高
java.util.LinkedList:链表落成,增加和删除元素效能高越发是全进度增加和删除成分。
E get(int index) 将钦定下标所对应的因素重返
E set(int index,E e)
将给定成分替换会集中钦定地点的因素并将被轮换来分再次回到。
1.8List_add_remove:List提供了壹对重载的add,remove方法也能够通过下标操作成分删除方法会重返3个去除的因素。
1.九获取List子集:List<E> subList(int startindex,int endindex)
截取会集中钦赐地方的成分,并回到截取的因素;操作获取的子集的时候就等于操作原有会集
1.十汇集调换为数组 —Collection中提供了将近来集合调换为3个数组的天下无双
E[] array= c.toArray(new
E[c.size()]);将聚合调换为数组,传三个泛型数组并安装长度,如若设置长度不够也会回到二个刚好和因素相等的数组,要是参数长度抢先原有数组,则赶回输入长度的数组,未有成分的地点为null。
壹.11数组更改为集聚—List<String> list =
Arrays.asList(array);将数组转化为汇集,操作再次来到后的集纳等于操作原来的数组,并且不能够增加和删除成分,要是想增新币素须要新建两个数组将重返数组的值传入并操作。
List<String> list1 = new
ArrayList<String>(list);那些办法能够在创设新数组的同时将原有数组的要素增添进去。

 

自家是初专家,如有更新不好的,招待这位大神建议,多谢大家!

越多优质今后更新,转发评释!

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

用二个 数组 举个例证:

 1> 遍历

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

  遍历:对聚集中成分依次收取的过称叫做遍历。

  三种艺术:一 for循环遍历; 2 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四, 56, 40, 5九,
60, 39, 壹, 40, 90, 48 

 2> for循环遍历

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

率先次巡回(i=0):壹, 89, 4, 34, 5陆, 40, 5玖, 60, 3九, 1, 40, 90,
4八 

  1 数组遍历

   原理:通过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, 59, 60, 3九, 一, 40, 90,
48 

  2 字典遍历

   原理:先拿走字典中存有的key,存款和储蓄到数组中,遍历数组依次抽出每2个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 **

其二回巡回(i=2):  一, 4, 8玖,
3四, 5陆, 40, 59, 60, 3九, 一, 40, 90, 4八 

  三 集结遍历

   原理:用集合的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
输出为字符串格局,而不是数组须求的数字下标,那意味着在少数景况下,会时有产生字符串运算,导致数据失实,举个例子:’5二’+1= ‘5二1’ 而不是大家须求的 五叁。

第6次巡回(i=三):一, 4, 3四,
8九, 56, 40, 5九, 60, 3玖, 1, 40, 90,
4八 

 3> NSEnumerator

其它 for in 循环的时候,不仅遍历本人的习性,还会找到 prototype
上去,所以最棒在循环体内加1个断定,就用
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

  2 数组遍历

   正序(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方法只好抽取2个对象,所以须要和while循环结合把富有因素依次抽取。

  三 字典遍历

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

  注:字典中存放的数据是冬季的,未有反向枚举的概念。

  4 集结遍历

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对象正是一个排序条件。

我们发掘,它们得以兑现均等的功能,事实上它们底层的管理是壹致的,可是 for
循环能够把定义、条件判定、自增自减操作放到三个尺码里执行,代码看起来方便一些,仅此而已。

 二> 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 不可变数组

排序

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
循环的2个变体,它首先实施二次操作,然后才开始展览规范剖断,是 true
的话再继续推行操作,是 false 的话循环结束。

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

   -
(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 循环

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

   - (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,那样就可以暂停循环了,要是您时常用那个艺术,最佳自定义叁个如此的
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()
方法再次回到3个新数组,数组中的成分为原始数组成分调用函数管理后的值。
瞩目: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()
方法接收七个函数作为累加器,数组中的每一个值(从左到右)初步滑坡,最终计算为一个值。

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 湖南中国广播公司泛的循环遍历方法,随着 Es陆标准的包容性越来越好,小编开采大多落到实处方案逐步都不再供给了,举例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地图