「javasub集合」集合 java
今天给各位分享javasub集合的知识，其中也会对集合 java进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java json取集合某个元素
- 2、java集合，定义两个类，学生Student和课程Course，课程被学生选修，请在课程类中提供以下功能：
- 3、java程序问题：我想把多个不同的list放到一个容器中如List或者map，
- 4、在Java中怎么把List集合中的对象分成每100条为一组
- 5、Java的List如何实现线程安全？
java json取集合某个元素
首先你的这个json串就有问题，修改下才能解析，解析方法如下
JSONObject log=jsonObject.getJSONObject("第一级Object");
JSONArray jsonArray = log.getJSONArray("Object中的array");
JSONObject pages = jsonArray.getJSONObject(0); //从jsonArray中解析第一个Object
JSONObject pageTimings=pages.getJSONObject("继续解析object");
String onContentLoad=pageTimings.getString("onContentLoad"); //得到想要的值
把{}大括号扩起来的看成是object，如果有名字就根据名字来解析，如果没名字就根据序号来解析，上面的代码两种情况均有涉及，请注意参考与更改变量名。[]扩起来的看成数组，用getArray解析，同样可以用名字或序号解析
java集合，定义两个类，学生Student和课程Course，课程被学生选修，请在课程类中提供以下功能：
Course类：
package com.goodprg.d1207.que1;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Course
{
private String name;
//选中此课程的学生成绩
private ListStudent stuList = new ArrayListStudent();
public Course()
{
super();
}
public Course(String name)
{
super();
this.name = name;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public ListStudent getStuList()
{
return stuList;
}
public void setStuList(ListStudent stuList)
{
this.stuList = stuList;
}
public void stuChoose(Student s)
{
this.stuList.add(s);
}
/**
* 计算平均值
*
* @return [参数说明]
*
* @return float [返回类型说明]
* @exception throws [违例类型] [违例说明]
* @see [类、类#方法、类#成员]
*/
public float getAvg()
{
int count = 0;
float total = 0;
for(Student s : stuList)
{
total = total + s.getScore();
count++;
}
if(count==0)
{
return 0;
}
return total / count;
}
/**
* 计算方差
*
* @return [参数说明]
*
* @return float [返回类型说明]
* @exception throws [违例类型] [违例说明]
* @see [类、类#方法、类#成员]
*/
public float getVariance()
{
if(stuList.size()==0)
{
return 0;
}
float avg = getAvg();
float totalTmp = 0;
for(Student s : stuList)
{
float sub = s.getScore() - avg;
totalTmp = sub * sub + totalTmp;
}
return totalTmp / stuList.size();
}
/**
* 求中位数
*
* @return [参数说明]
*
* @return float [返回类型说明]
* @exception throws [违例类型] [违例说明]
* @see [类、类#方法、类#成员]
*/
public float getMedian()
{
if(stuList.size()==0)
{
return 0;
}
int inx = stuList.size() / 2;
int mod = stuList.size() % 2;
//排序集合
Collections.sort(stuList);
//个数为奇数
if(mod==1)
{
return stuList.get(inx).getScore();
}
//个数为偶数
else
{
float s1 = stuList.get(inx-1).getScore();
float s2 = stuList.get(inx).getScore();
return (s1+s2)/2;
}
}
/**
* 排序后，返回的list
*
* @return [参数说明]
*
* @return ListStudent [返回类型说明]
* @exception throws [违例类型] [违例说明]
* @see [类、类#方法、类#成员]
*/
public ListStudent sortStudents()
{
Collections.sort(stuList);
return stuList;
}
public static void main(String[] args)
{
int a = 9/2;
System.out.println(a);
}
}
Student类：
package com.goodprg.d1207.que1;
public class Student implements ComparableStudent
{
//学生姓名
private String name;
//课程成绩
private float score;
public Student()
{
super();
}
public Student(String name, float score)
{
super();
this.name = name;
this.score = score;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public float getScore()
{
return score;
}
public void setScore(float score)
{
this.score = score;
}
@Override
public int compareTo(Student o)
{
int res = this.scoreo.score ? 1 : (this.score==o.score ? 0 : -1);
return res;
}
@Override
public String toString()
{
return "学生：【" + name + "】成绩为：" + score;
}
}
测试类：
package com.goodprg.d1207.que1;
import java.util.List;
public class Test
{
public static void main(String[] args)
{
Student s1 = new Student("张一",92);
Student s2 = new Student("张二",83);
Student s3 = new Student("张三",77);
Student s4 = new Student("张四",99);
Course cs = new Course("马列主义");
cs.stuChoose(s1);
cs.stuChoose(s2);
cs.stuChoose(s3);
cs.stuChoose(s4);
//平均值
System.out.println("课程【"+cs.getName()+"】学生平均值："+cs.getAvg());
System.out.println("课程【"+cs.getName()+"】学生成绩方差："+cs.getVariance());
System.out.println("课程【"+cs.getName()+"】学生成绩中位数："+cs.getMedian());
System.out.println("课程【"+cs.getName()+"】学生成绩排序如下：");
ListStudent sortStus = cs.sortStudents();
for(Student s : sortStus)
{
System.out.println(s);
}
}
}
运行结果
课程【马列主义】学生平均值：87.75
课程【马列主义】学生成绩方差：70.6875
课程【马列主义】学生成绩中位数：87.5
课程【马列主义】学生成绩排序如下：
学生：【张三】成绩为：77.0
学生：【张二】成绩为：83.0
学生：【张一】成绩为：92.0
学生：【张四】成绩为：99.0
java程序问题：我想把多个不同的list放到一个容器中如List或者map，
public static void main(String[] args) {
ListList total = new ArrayList();
ListString sub1 = new ArrayList();
ListInteger sub2 = new ArrayList();
sub1.add("a"); sub1.add("b");
sub2.add(1);sub2.add(2);
total.add(sub1);
total.add(sub2);
Iterator itsub1 = total.get(0).iterator();
while(itsub1.hasNext()) {
System.out.println(itsub1.next());
}
Iterator itsub2 = total.get(1).iterator();
while(itsub2.hasNext()) {
System.out.println(itsub2.next());
}
}
这样操作不好操作的，如果实在想弄到一起，把多个集合放到一个类里就行了。
在Java中怎么把List集合中的对象分成每100条为一组
分组的话 可不可以考虑从0到99提取出来存到另一个List，然后100到199存到下一个List，依次类推呢？利用for循环应该能做到
Java的List如何实现线程安全？
Java的List如何实现线程安全？
Collections.synchronizedList(names);效率最高，线程安全
Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？
加锁
首先大家会想到用Vector，这里我们就不讨论了，首先讨论的是加锁，例如下面的代码
public class Synchronized{
private ListString names = new LinkedList();
public synchronized void addName(String name ){
names.add("abc");
}
public String getName(Integer index){
Lock lock =new ReentrantLock();
lock.lock();
try {
return names.get(index);
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
return null;
}
}
synchronized一加，或者使用lock 可以实现线程安全，但是这样的List要是很多个，代码量会大大增加。
java自带类
在java中我找到自带有两种方法
CopyOnWriteArrayList
CopyOnWrite 写入时复制，它使一个List同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。
下面是add方法的源代码
public boolean add(E e) {
final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 创建个长度加1的数组并复制过去
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e; // 赋值
setArray(newElements); // 设置内部的数组
return true;
} finally {
lock.unlock();
}
}
Collections.synchronizedList
Collections中有许多这个系列的方法例如
主要是利用了装饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList
static class SynchronizedListE
extends SynchronizedCollectionE
implements ListE {
private static final long serialVersionUID = -7754090372962971524L;
final ListE list;
SynchronizedList(ListE list) {
super(list);
this.list = list;
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}
static class SynchronizedCollectionE implements CollectionE, Serializable {
private static final long serialVersionUID = 3053995032091335093L;
final CollectionE c; // Backing Collection
final Object mutex; // Object on which to synchronize
这里上面的mutex就是锁的对象 在构建时候可以指定锁的对象 主要使用synchronize关键字实现线程安全
/**
* @serial include
*/
static class SynchronizedListE
extends SynchronizedCollectionE
implements ListE {
private static final long serialVersionUID = -7754090372962971524L;
final ListE list;
SynchronizedList(ListE list) {
super(list);
this.list = list;
}
SynchronizedList(ListE list, Object mutex) {
super(list, mutex);
this.list = list;
}
这里只是列举SynchronizedList ，其他类类似，可以看下源码了解下。
测试
public class Main {
public static void main(String[] args) {
ListString names = new LinkedList();
names.add("sub");
names.add("jobs");
// 同步方法1 内部使用lock
long a = System.currentTimeMillis();
ListString strings = new CopyOnWriteArrayList(names);
for (int i = 0; i 100000; i++) {
strings.add("param1");
}
long b = System.currentTimeMillis();
// 同步方法2 装饰器模式使用 synchronized
ListString synchronizedList = Collections.synchronizedList(names);
for (int i = 0; i 100000; i++) {
synchronizedList.add("param2");
}
long c = System.currentTimeMillis();
System.out.println("CopyOnWriteArrayList time == "+(b-a));
System.out.println("Collections.synchronizedList time == "+(c-b));
}
}
两者内部使用的方法都不一样，CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问，synchronizedList使用的是synchronize
进行了100000次添加后时间对比如下：
可以看出来还是使用了synchronize的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。
关于javasub集合和集合 java的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-12-21，除非注明，否则均为原创文章，转载请注明出处。