list 常见循环案例

最新推荐文章于 2022-01-24 12:05:53 发布
最新推荐文章于 2022-01-24 12:05:53 发布
阅读量203 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigtree_/article/details/96482122
版权

list 常见循环案例

package com.oldnoop.java.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;

import org.junit.Test;

public class ListDemo {

	@Test
	public void testLoop() {
		List<Integer> list = Arrays.asList(1, 5, 8, 3, 9, 2);
		// 用下标循环
		System.out.println("------------index---------------");
		for (int i = 0; i < list.size(); i++) {
			Integer integer = list.get(i);
			System.out.println(integer);
		}
		for (int i = 0, length = list.size(); i < length; i++) {
			Integer integer = list.get(i);
			System.out.println(integer);
		}
		System.out.println("------------iterator---------------");
		// 用迭代器
		for (Iterator<Integer> iterator = list.iterator(); iterator.hasNext();) {
			Integer integer = (Integer) iterator.next();
			System.out.println(integer);
		}
		System.out.println("------------foreach---------------");
		// 用foreach
		for (Integer integer : list) {
			System.out.println(integer);
		}
		System.out.println("-----------stream----------------");
		list.stream().forEach(System.out::println);
		System.out.println("-----------stream2----------------");
		list.stream().forEach((x) -> {
			System.out.println(x);
		});
	}

	// 查找集合中满足条件的元素
	@Test
	public void testFindEle() {
		List<Product> products = findProductsFromDB();
		// 查找小米品牌的商品
		List<Product> productsXiaomi = new ArrayList<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			if ("小米".equals(product.getBrand())) {
				productsXiaomi.add(product);
			}
		}
		System.out.println(productsXiaomi);
		// 查找手机分类的商品
		List<Product> productsMobile = new ArrayList<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			if ("手机".equals(product.getCategory())) {
				productsMobile.add(product);
			}
		}
		System.out.println(productsMobile);
		// 查找小米品牌的手机
		List<Product> productsXiaomiMobile = new ArrayList<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			if ("小米".equals(product.getBrand()) && "手机".equals(product.getCategory())) {
				productsXiaomiMobile.add(product);
			}
		}
		System.out.println(productsXiaomiMobile);

		// 查找价格高于3000的手机
		List<Product> productsMobile3000 = new ArrayList<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			if ("手机".equals(product.getCategory()) && product.getPrice() != null && product.getPrice() > 3000) {
				productsMobile3000.add(product);
			}
		}
		System.out.println(productsMobile3000);

		// 查找价格高于2000的小米手机
		List<Product> productsXiaomiMobile2000 = new ArrayList<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			if ("手机".equals(product.getCategory()) && "小米".equals(product.getBrand()) && product.getPrice() != null
					&& product.getPrice() > 2000) {
				productsXiaomiMobile2000.add(product);
			}
		}
		System.out.println(productsXiaomiMobile2000);
		System.out.println("-----------------使用stream查找集合中满足条件的元素---------------------");
		productsXiaomiMobile2000 = products.stream().filter(product -> "手机".equals(product.getCategory())
				&& "小米".equals(product.getBrand()) && product.getPrice() != null && product.getPrice() > 2000)
				.collect(Collectors.toList());
		System.out.println(productsXiaomiMobile2000);
	}

	// 统计
	@Test
	public void testStat() {
		List<Product> products = findProductsFromDB();
		// 按分类 对商品进行分组
		// key -> 分类, value是这个分类的商品集合
		Map<String, List<Product>> productsCategoryMap = new HashMap<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			String category = product.getCategory();
			// 判断map中 分类对应的 商品集合是否为null
			List<Product> list = productsCategoryMap.get(category);
			if (list != null) {// 不为null
				// 有则直接使用
				list.add(product);
			} else {// 为null
					// 无则添加
				list = new ArrayList<>();
				list.add(product);
				productsCategoryMap.put(category, list);
			}
		}
		System.out.println(productsCategoryMap);
		// 按品牌对商品进行分组
		// key -> 品牌, value是这个品牌的商品集合
		Map<String, List<Product>> productsBrandMap = new HashMap<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			String brand = product.getBrand();
			// 判断map中 品牌对应的 商品集合是否为null
			List<Product> list = productsBrandMap.get(brand);
			if (list != null) {// 不为null
				// 有则直接使用
				list.add(product);
			} else {// 为null
					// 无则添加
				list = new ArrayList<>();
				list.add(product);
				productsBrandMap.put(brand, list);
			}
		}
		System.out.println(productsBrandMap);

		// key -> 分类_品牌, value是这个品牌_分类的商品集合
		Map<String, List<Product>> productsCateBrandMap = new HashMap<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			String category = product.getCategory();
			String brand = product.getBrand();
			String key = category + "_" + brand;
			// 判断map中 key对应的 商品集合是否为null
			List<Product> list = productsCateBrandMap.get(key);
			if (list != null) {// 不为null
				// 有则直接使用
				list.add(product);
			} else {// 为null
					// 无则添加
				list = new ArrayList<>();
				list.add(product);
				productsCateBrandMap.put(key, list);
			}
		}
		System.out.println(productsCateBrandMap);
		System.out.println("-----------------stream分组----------------------");

		productsCateBrandMap = products.stream()
				.collect(Collectors.groupingBy(product -> product.getCategory() + "_" + product.getBrand()));
		System.out.println(productsCateBrandMap);

		// 按分类,品牌对商品进行分组
		// key -> category 分类,value -> Map (key -> brand品牌, value
		// 是商品集合List<Product>)
		Map<String, Map<String, List<Product>>> productsCateBrandMap2 = new HashMap<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			String category = product.getCategory();
			String brand = product.getBrand();
			// 判断map中key->category分类 对应的 品牌map(productsBrandMap2)是否为null
			Map<String, List<Product>> productsBrandMap2 = productsCateBrandMap2.get(category);
			if (productsBrandMap2 != null) {
				// 拿到分类对应的品牌map -> key是brand品牌,value是商品集合List
				List<Product> list = productsBrandMap2.get(brand);
				if (list != null) {
					list.add(product);
				} else {
					list = new ArrayList<>();
					list.add(product);
					productsBrandMap2.put(brand, list);
				}
			} else {
				productsBrandMap2 = new HashMap<>();
				productsCateBrandMap2.put(category, productsBrandMap2);

				ArrayList<Product> list = new ArrayList<>();
				list.add(product);
				productsBrandMap2.put(brand, list);
			}

		}
		System.out.println(productsCateBrandMap2);
		System.out.println("-----------------stream分组----------------------");

	}

	// 排序
	@Test
	public void testSort() {
		List<Product> products = findProductsFromDB();
		// 按价格对小米的商品进行升序排序
		List<Product> productsXiaomi = new ArrayList<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			if ("小米".equals(product.getBrand())) {
				productsXiaomi.add(product);
			}
		}
		Collections.sort(productsXiaomi, new Comparator<Product>() {
			@Override
			public int compare(Product o1, Product o2) {
				double price1 = o1.getPrice() == null ? 0 : o1.getPrice();
				double price2 = o2.getPrice() == null ? 0 : o2.getPrice();
				return (price1 >= price2) ? 1 : -1;
			}
		});
		productsXiaomi.stream().forEach(System.out::println);
		System.out.println("----------------使用stream------------------");
		productsXiaomi = products.stream()
				.filter(product -> "小米".equals(product.getBrand()))
				.sorted(
						(o1,o2)-> {
							double price1 = o1.getPrice() == null ? 0 : o1.getPrice();
							double price2 = o2.getPrice() == null ? 0 : o2.getPrice();
							return (price1 >= price2) ? 1 : -1;
						}
				)
				.collect(Collectors.toList());
		productsXiaomi.stream().forEach(System.out::println);
		
		// 按价格对不同分类的商品进行排序
		// 按分类 对商品进行分组
		// key -> 分类, value是这个分类的商品集合
		Map<String, List<Product>> productsCategoryMap = new HashMap<>();
		for (int i = 0; i < products.size(); i++) {
			Product product = products.get(i);
			String category = product.getCategory();
			// 判断map中 分类对应的 商品集合是否为null
			List<Product> list = productsCategoryMap.get(category);
			if (list != null) {// 不为null
				// 有则直接使用
				list.add(product);
			} else {// 为null
					// 无则添加
				list = new ArrayList<>();
				list.add(product);
				productsCategoryMap.put(category, list);
			}
		}
		//排序
		for(Iterator<Entry<String, List<Product>>> iter = 
				productsCategoryMap.entrySet().iterator();iter.hasNext();){
			Entry<String, List<Product>> entry = iter.next();
			List<Product> value = entry.getValue();
			Collections.sort(value, new Comparator<Product>() {
				@Override
				public int compare(Product o1, Product o2) {
					double price1 = o1.getPrice() == null ? 0 : o1.getPrice();
					double price2 = o2.getPrice() == null ? 0 : o2.getPrice();
					return (price1 >= price2) ? 1 : -1;
				}
			});
			System.out.println("分类:"+entry.getKey());
			value.stream().forEach(System.out::println);
		}
		System.out.println("----------------使用stream排序分组------------------");
		productsCategoryMap = products.stream()
		.sorted(
				(o1,o2)-> {
					double price1 = o1.getPrice() == null ? 0 : o1.getPrice();
					double price2 = o2.getPrice() == null ? 0 : o2.getPrice();
					return (price1 >= price2) ? 1 : -1;
				}
		)
		.collect(Collectors.groupingBy(product -> product.getCategory()));
		System.out.println("----------------使用stream排序分组测试------------------");
		for(Iterator<Entry<String, List<Product>>> iter = 
				productsCategoryMap.entrySet().iterator();iter.hasNext();){
			Entry<String, List<Product>> entry = iter.next();
			List<Product> value = entry.getValue();
			System.out.println("分类:"+entry.getKey());
			value.stream().forEach(System.out::println);
		}
		
		// 按价格对不同品牌的商品进行排序
	}

	// 查找2个集合中相同的商品
	@Test
	public void testFindSame() {
		// 按id相等为相同商品的原则
		List<Product> list1 = findProductsFromDB();
		List<Product> list2 = findProductsFromDB2();
	}

	// 模拟从数据库得到集合数据
	public List<Product> findProductsFromDB() {
		AtomicLong ids = new AtomicLong();
		String[] names = { "小米9", "THINKPAD R720", "MACBOOK AIR", "DELL 游侠", "oppo FindX", "HP 暗影精灵4", "小米电源",
				"iphone XR" };
		String[] categories = { "手机", "笔记本", "电源" };
		String[] brands = { "小米", "thinkpad", "苹果", "DELL", "OPPO", "惠普" };
		Double[] prices = { 2999.00, 5199.00, 9499.00, 6000.00, 4999.00, 8250.00, 49.00, 6599.00 };
		Product product0 = new Product(ids.incrementAndGet(), names[0], categories[0], brands[0], prices[0]);
		Product product1 = new Product(ids.incrementAndGet(), names[1], categories[1], brands[1], prices[1]);
		Product product2 = new Product(ids.incrementAndGet(), names[2], categories[1], brands[2], prices[2]);
		Product product3 = new Product(ids.incrementAndGet(), names[3], categories[1], brands[3], prices[3]);
		Product product4 = new Product(ids.incrementAndGet(), names[4], categories[0], brands[4], prices[4]);
		Product product5 = new Product(ids.incrementAndGet(), names[5], categories[1], brands[5], prices[5]);
		Product product6 = new Product(ids.incrementAndGet(), names[6], categories[2], brands[0], prices[6]);
		Product product7 = new Product(ids.incrementAndGet(), names[7], categories[0], brands[2], prices[7]);
		return Arrays.asList(product0, product1, product2, product3, product4, product5, product6, product7);
	}

	// 模拟从数据库得到集合数据
	public List<Product> findProductsFromDB2() {
		List<Product> products = findProductsFromDB();
		products.remove(0);
		products.remove(2);
		products.remove(4);
		return products;
	}

	private static class Product {
		private Long id;
		private String name;
		private String category;
		private String brand;
		private Double price;

		public Product() {
			super();
		}

		public Product(Long id, String name, String category, String brand, Double price) {
			super();
			this.id = id;
			this.name = name;
			this.category = category;
			this.brand = brand;
			this.price = price;
		}

		public Long getId() {
			return id;
		}

		public void setId(Long id) {
			this.id = id;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public String getCategory() {
			return category;
		}

		public void setCategory(String category) {
			this.category = category;
		}

		public String getBrand() {
			return brand;
		}

		public void setBrand(String brand) {
			this.brand = brand;
		}

		public Double getPrice() {
			return price;
		}

		public void setPrice(Double price) {
			this.price = price;
		}

		@Override
		public String toString() {
			return "Product [id=" + id + ", name=" + name + ", category=" + category + ", brand=" + brand + ", price="
					+ price + "]";
		}

	}
}
辉~情
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Vue组件模板形式实现对象数组数据循环为树形结构(实例代码)
12-29
数据结构为数组中包含对象–树形结构，用Vue组件的写法实现以下的效果： 树形列表，缩进显示层级，第5级数据加底色，数据样式显色，点击展开折叠数据。本文为用Vue实现方式，另有一篇为用knockout.js的实现方法。 html代码 <div id=table-component-div> <table v-for=item v-bind:list=item></table> </div> 组件模板代码 <script type=text/x-template id=table-component-tem
实例 - 购物车 （列表、循环）
weixin_30245867的博客
02-22 261
salary = int(input('Please input your money:')) product = [ ('iphone6s',5800), ('mac bood',9000), ('coffee',32), ('python book',80), ('bicyle',1500), ] shopping = ...
Java集合框架——List集合遍历的案例实操
kingdom_C的博客
02-07 210
Java集合框架——集合遍历的案例实操
利用集合（ArrayList），数组，泛型，增强for循环知识，写一个案例：斗地主小游戏，实现建牌，洗牌，发牌功能。
小邹的博客
07-24 187
步骤： 第一步：创建牌，用三个集合来装，数据类型是String，集合用Arr…的，第一个数组装花色，第二个数组装牌值（除去大小王）,第三个集合装整副牌（将花色和牌值结合）。 第二步：洗牌，使用Collections工具类中的方法：static void shuffle(List<?> list):使用指定的随机源对指定列表进行置换，即打乱牌序。 第三步：发牌，玩家三名,底牌三张。定义四个集合，三个存储玩家牌，一个存储底牌，用for循环与if语句实现。 代码： import java.util.A
mysql 存储过程 查询结果循环插入
weixin_42072721的博客
01-24 3640
A表 -- ---------------------------- -- Table structure for test1 -- ---------------------------- DROP TABLE IF EXISTS `test1`; CREATE TABLE `test1` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `name` varchar(255) COLLATE utf8mb4_bin NOT NULL, `type` t
java list随机抽取元素的案例
09-07
常见的`List`实现包括`ArrayList`和`LinkedList`。在这个案例中，我们将讨论如何从`List`中随机抽取元素。 **随机抽取元素的案例** 在提供的代码段中，定义了一个名为`createRandomList`的方法，它接受一个`List`...
基于Django的博客系统案例
02-24
在模板中，可以使用Django模板语言（DTL）进行条件判断、循环和变量替换。 6. **表单处理** 博客系统通常包含发表新文章的功能，这涉及到表单处理。Django的表单库简化了这一过程。在`blog_app/forms.py`定义`Post...
JAVA新手入门60个案例.zip
01-29
1. **基本语法**：案例可能涵盖变量声明、数据类型、运算符、流程控制（如if语句、switch语句、循环）、方法定义与调用等基础概念，帮助初学者建立编程基础。 2. **面向对象**：Java的核心在于面向对象编程，案例中...
java上机案例、题目
01-23
- List，Set，Map接口：掌握ArrayList，LinkedList，HashSet，HashMap等常用实现类的使用。 - 遍历和迭代器：了解foreach循环和Iterator接口的使用。 6. **IO流** - 输入/输出流：学习如何读写文件，包括字符流...
C#程序入门应用案例.zip
11-03
3. **控制结构**：包括条件语句（if-else）、循环（for、while、foreach）、跳转语句（break、continue），这些是编写逻辑流程的关键。 4. **函数**：函数是C#中的可重用代码块，用于执行特定任务。学习如何定义和...
java不用循环语句打印数组元素的实例
08-31
下面小编就为大家带来一篇java不用循环语句打印数组元素的实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
pythonwhile列表_python while、for循环、list列表
weixin_39549936的博客
11-22 320
1、while循环（循环也可叫迭代、遍历）while 循环 必须有一个计数器count=0while count0:print('用户已存在')方法2：if username in stus:print('用户已存在')if username not in stus:print('用户不存在')...
for in for of区别_通过几个事例，就可以说明 for...of 循环在 JS 是不可或缺
weixin_39947812的博客
11-23 111
请教大家一个问题：什么特性让该编程语言更加优秀?个人见解：当该特性可以组合多个其他语言特性时。JavaScript 中的for...of语句就是这种情况，可从ES2015开始使用。for...of可以迭代数组，类似数组的对象以及通常所有可迭代的对象(map，set，DOM集合)。接下我们通过事例来看看 for...of 一些有用的地方。1. 数组的迭代for...of的最常见应用是对数组项进行迭代...
python while、for循环、list列表
weixin_30252709的博客
06-01 130
1、while循环（循环也可叫迭代、遍历） 　　while 循环 必须有一个计数器 　count=0 　while count<10: 　　　print('hello') 　　　count=count+1 2、猜数字游戏例子 import random　　　　#引用随机数模块 num=random.randint(1,100) #随机产生一个数字，1到100 c...
实验案例2-2：数组元素循环右移问题
weixin_34233856的博客
09-20 232
1.C++方法，利用rotate函数 rotate(beg, mid, end),该函数接受三个迭代器， 将迭代器所在的容器的元素循环移动，使得mid元素成为首元素，随后是mid + 1到end之前的元素， 再接着是beg到mid 之间的元素，返回一个迭代器，指向原来在beg位置的元素 rotate_copy(beg, mid, end, dest),即将变换过后的元素保存在目的容器的dest位...
循环一个节点列表(NodeList)或者数组,并且绑定事件处理函数引发对闭包的理解...
weixin_30457881的博客
05-16 275
循环一个节点列表(NodeList)或者数组,并且绑定事件处理函数引发对闭包的理解 当然可以使用事件委托来实现，而且性能更好，但是这里纯粹为了理解这个问题。 我在网上查阅了很多资料，有了一点理解，记录下来。如果有不对的地方，各位看客请指正。 代码如下： HTML结构<div id='one'></div>...
基本循环条件语句及数组
09-29 657
if 语句 1 尽量使用肯定的表达式表述逻辑 2 减少多层嵌套。一般不超过2层 3 减少写else 练习：判断是否有航班 条件：byte date = 0x69;// 01101001 4 01101001 00010000 int day = 4;
Java Arrays.asList 实例
一个无限死循环的博客
02-20 453
// list长度为3 List list = Arrays.asList("a","b","c");// list长度为1， 因为考虑1.4语法 String[] arr = {"a","b","c"}; List list = Arrays.asList(arr); // 同时符合1.4和1.5的语法,此时会优先考虑1.4的语法 // 原因是有了新功能要保证以前的代码不出错，向后兼容 //将ar
#list 标签获取下标
yayayu_的博客
05-27 5423
<#list>标签 <#list>能是CMS里面的标签。 <#list>获取下标，怎么获取下标 ${c_index}获取下标 例子： [#list tag_list as c] ======> ${c_index} [#list tag_list as a] ======> ${a_index} 代码例子： <div class="tabs fn-clear"> [@cms_conten
vue中for循环成绩相加
最新发布
07-28
- *1* *3* [for循环以及案例](https://blog.csdn.net/weixin_48501207/article/details/123037101)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值