总结

以上是小编为你收集整理的excel标准差函数是什么 excel怎么计算标准差全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

今天关于如何使用JAVA计算标准差和如何使用java计算标准差值的讲解已经结束，谢谢您的阅读，如果想了解更多关于excel如何计算标准差、excel怎么算标准差、excel怎么算标准差？excel计算标准差方法介绍、excel标准差函数是什么 excel怎么计算标准差的相关知识，请在本站搜索。

关于Python-给定2个句子字符串，计算余弦相似度和python两个字符串匹配的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于C# Net 比较2个字符串的相似度（使用余弦相似度）、java – 如何有效地计算数百万字符串之间的余弦相似度、java算法之余弦相似度计算字符串相似率、KNN cosine 余弦相似度计算等相关知识的信息别忘了在本站进行查找喔。

• Python-给定2个句子字符串，计算余弦相似度（python两个字符串匹配）
• C# Net 比较2个字符串的相似度（使用余弦相似度）
• java – 如何有效地计算数百万字符串之间的余弦相似度
• java算法之余弦相似度计算字符串相似率
• KNN cosine 余弦相似度计算

Python-给定2个句子字符串，计算余弦相似度（python两个字符串匹配）

从Python：tf-idf-cosine：查找文档相似度，可以使用tf-idf余弦计算文档相似度。如果不导入外部库，是否有任何方法可以计算2个字符串之间的余弦相似度？

s1 = "This is a foo bar sentence ."s2 = "This sentence is similar to a foo bar sentence ."s3 = "What is this string ? Totally not related to the other two lines ."cosine_sim(s1, s2) # Should give high cosine similaritycosine_sim(s1, s3) # Shouldn''t give high cosine similarity valuecosine_sim(s2, s3) # Shouldn''t give high cosine similarity value

答案1

一个简单的纯Python实现是：

import re, mathfrom collections import CounterWORD = re.compile(r''\w+'')def get_cosine(vec1, vec2):     intersection = set(vec1.keys()) & set(vec2.keys())     numerator = sum([vec1[x] * vec2[x] for x in intersection])     sum1 = sum([vec1[x]**2 for x in vec1.keys()])     sum2 = sum([vec2[x]**2 for x in vec2.keys()])     denominator = math.sqrt(sum1) * math.sqrt(sum2)     if not denominator:        return 0.0     else:        return float(numerator) / denominatordef text_to_vector(text):     words = WORD.findall(text)     return Counter(words)text1 = ''This is a foo bar sentence .''text2 = ''This sentence is similar to a foo bar sentence .''vector1 = text_to_vector(text1)vector2 = text_to_vector(text2)cosine = get_cosine(vector1, vector2)print ''Cosine:'', cosine

印刷品：

Cosine: 0.861640436855

这里所用的余弦公式描述这里。

这不包括通过tf-idf对单词进行加权，但是为了使用tf-idf，你需要具有一个相当大的语料库才能从中估计tfidf的权重。

你还可以通过使用更复杂的方法从一段文本中提取单词，对其进行词干或词义化等来进一步开发它。

C# Net 比较2个字符串的相似度（使用余弦相似度）

C# Net 比较2个字符串的相似度（使用余弦相似度）

复制代码使用：

　　　　　/// <summary>
        /// 比较2个字符串的相似度（使用余弦相似度）
        /// </summary>
        /// <param name="str1"></param>
        /// <param name="str2"></param>
        /// <returns>0-1之间的数</returns>
        public static double SimilarityCos(string str1, string str2)
        {
            str1 = str1.Trim();
            str2 = str2.Trim();
            if (string.IsNullOrEmpty(str1) || string.IsNullOrEmpty(str2))
                return 0;

            List<string> lstr1 = SimpParticiple(str1);
            List<string> lstr2 = SimpParticiple(str2);
            //求并集
            var strUnion = lstr1.Union(lstr2);
            //求向量
            List<int> int1 = new List<int>();
            List<int> int2 = new List<int>();
            foreach (var item in strUnion)
            {
                int1.Add(lstr1.Count(o => o == item));
                int2.Add(lstr2.Count(o => o == item));
            }

            double s = 0;
            double den1 = 0;
            double den2 = 0;
            for (int i = 0; i < int1.Count(); i++)
            {
                //求分子
                s += int1[i] * int2[i];
                //求分母（1）
                den1 += Math.Pow(int1[i], 2);
                //求分母（2）
                den2 += Math.Pow(int2[i], 2);
            }

            return s / (Math.Sqrt(den1) * Math.Sqrt(den2));
        }

        /// <summary>
        /// 简单分词（需要更好的效果，需要这里优化，比如把：【今天天气很好】，分成【今天，天气，很好】，同时可以做同义词优化，【今天】=【今日】效果更好）
        /// </summary>
        public static List<string> SimpParticiple(string str)
        {
            List<string> vs = new List<string>();
            foreach (var item in str)
            {
                vs.Add(item.ToString());
            }
            return vs;
        }

java – 如何有效地计算数百万字符串之间的余弦相似度

java算法之余弦相似度计算字符串相似率

这篇文章主要介绍了java算法之余弦相似度计算字符串相似率，对算法感兴趣的同学，可以参考下

目录

概述

一、理论知识

1、说重点

2、案例理论知识

二、实际开发案例

1、pom.xml

2、main方法

3、Tokenizer（分词工具类）

4、Word（封装分词结果）

5、Cosinesimilarity（相似率具体实现工具类）

6、AtomicFloat原子类

三、总结

概述

功能需求：最近在做通过爬虫技术去爬取各大相关网站的新闻，储存到公司数据中。这里面就有一个技术点，就是如何保证你已爬取的新闻，再有相似的新闻

或者一样的新闻，那就不存储到数据库中。（因为有网站会去引用其它网站新闻，或者把其它网站新闻拿过来稍微改下内容就发布到自己网站中）。

解析方案：最终就是采用余弦相似度算法，来计算两个新闻正文的相似度。现在自己写一篇博客总结下。

一、理论知识

先推荐一篇博客，对于余弦相似度算法的理论讲的比较清晰，我们也是按照这个方式来计算相似度的。网址：相似度算法之余弦相似度。

1、说重点

我这边先把计算两个字符串的相似度理论知识再梳理一遍。

（1）首先是要明白通过向量来计算相识度公式。

（2）明白：余弦值越接近1，也就是两个向量越相似，这就叫"余弦相似性"，

余弦值越接近0，也就是两个向量越不相似，也就是这两个字符串越不相似。

2、案例理论知识

举一个例子来说明，用上述理论计算文本的相似性。为了简单起见，先从句子着手。

句子A：这只皮靴号码大了。那只号码合适。

句子B：这只皮靴号码不小，那只更合适。

怎样计算上面两句话的相似程度？

基本思路是：如果这两句话的用词越相似，它们的内容就应该越相似。因此，可以从词频入手，计算它们的相似程度。

第一步，分词。

句子A：这只/皮靴/号码/大了。那只/号码/合适。

句子B：这只/皮靴/号码/不/小，那只/更/合适。

第二步，计算词频。（也就是每个词语出现的频率）

句子A：这只1，皮靴1，号码2，大了1。那只1，合适1，不0，小0，更0

句子B：这只1，皮靴1，号码1，大了0。那只1，合适1，不1，小1，更1

第三步，写出词频向量。

句子A：(1，1，2，1，1，1，0，0，0)

句子B：(1，1，1，0，1，1，1，1，1)

第四步：运用上面的公式：计算如下：

计算结果中夹角的余弦值为0.81非常接近于1，所以，上面的句子A和句子B是基本相似的

二、实际开发案例

我把我们实际开发过程中字符串相似率计算代码分享出来。

1、pom.xml

展示一些主要jar包

org.apache.commonscommons-lang33.5org.projectlomboklombokcom.hankcshanlpportable-1.6.5

2、main方法

/** * 计算两个字符串的相识度 */ public class Similarity { public static final String content1="今天小小和爸爸一起去摘草莓，小小说今天的草莓特别的酸，而且特别的小，关键价格还贵"; public static final String content2="今天小小和妈妈一起去草原里采草莓，今天的草莓味道特别好，而且价格还挺实惠的"; public static void main(String[] args) { double score=Cosinesimilarity.getSimilarity(content1,content2); System.out.println("相似度："+score); score=Cosinesimilarity.getSimilarity(content1,content1); System.out.println("相似度："+score); } }

先看运行结果：

通过运行结果得出：

（1）第一次比较相似率为：0.772853 （说明这两条句子还是挺相似的），第二次比较相似率为：1.0 （说明一模一样）。

（2）我们可以看到这个句子的分词效果，后面是词性。

3、Tokenizer（分词工具类）

import com.hankcs.hanlp.HanLP; import com.hankcs.hanlp.seg.common.Term; import java.util.List; import java.util.stream.Collectors; /** * 中文分词工具类*/ public class Tokenizer { /** * 分词*/ public static List segment(String sentence) { //1、 采用HanLP中文自然语言处理中标准分词进行分词 List termlist = HanLP.segment(sentence); //上面控制台打印信息就是这里输出的 System.out.println(termlist.toString()); //2、重新封装到Word对象中（term.word代表分词后的词语，term.nature代表改词的词性） return termlist.stream().map(term -> new Word(term.word, term.nature.toString())).collect(Collectors.toList()); } }

4、Word（封装分词结果）

这里面真正用到的其实就词名和权重。

import lombok.Data; import java.util.Objects; /** * 封装分词结果*/ @Data public class Word implements Comparable { // 词名 private String name; // 词性 private String pos; // 权重，用于词向量分析 private Float weight; public Word(String name, String pos) { this.name = name; this.pos = pos; } @Override public int hashCode() { return Objects.hashCode(this.name); } @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final Word other = (Word) obj; return Objects.equals(this.name, other.name); } @Override public String toString() { StringBuilder str = new StringBuilder(); if (name != null) { str.append(name); } if (pos != null) { str.append("/").append(pos); } return str.toString(); } @Override public int compareto(Object o) { if (this == o) { return 0; } if (this.name == null) { return -1; } if (o == null) { return 1; } if (!(o instanceof Word)) { return 1; } String t = ((Word) o).getName(); if (t == null) { return 1; } return this.name.compareto(t); } }

5、Cosinesimilarity（相似率具体实现工具类）

import com.jincou.algorithm.tokenizer.Tokenizer; import com.jincou.algorithm.tokenizer.Word; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.util.CollectionUtils; import java.math.BigDecimal; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; /** * 判定方式：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 余弦夹角原理： 向量a=(x1,y1),向量b=(x2,y2) similarity=a.b/|a|*|b| a.b=x1x2+y1y2 * |a|=根号[(x1)^2+(y1)^2],|b|=根号[(x2)^2+(y2)^2]*/ public class Cosinesimilarity { protected static final Logger LOGGER = LoggerFactory.getLogger(Cosinesimilarity.class); /** * 1、计算两个字符串的相似度 */ public static double getSimilarity(String text1, String text2) { //如果wei空，或者字符长度为0，则代表完全相同 if (StringUtils.isBlank(text1) && StringUtils.isBlank(text2)) { return 1.0; } //如果一个为0或者空，一个不为，那说明完全不相似 if (StringUtils.isBlank(text1) || StringUtils.isBlank(text2)) { return 0.0; } //这个代表如果两个字符串相等那当然返回1了（这个我为了让它也分词计算一下，所以注释掉了） // if (text1.equalsIgnoreCase(text2)) { // return 1.0; // } //第一步：进行分词 List words1 = Tokenizer.segment(text1); List words2 = Tokenizer.segment(text2); return getSimilarity(words1, words2); } /** * 2、对于计算出的相似度保留小数点后六位 */ public static double getSimilarity(List words1, List words2) { double score = getSimilarityImpl(words1, words2); //(int) (score * 1000000 + 0.5)其实代表保留小数点后六位 ,因为1034234.213强制转换不就是1034234。对于强制转换添加0.5就等于四舍五入 score = (int) (score * 1000000 + 0.5) / (double) 1000000; return score; } /** * 文本相似度计算 判定方式：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 余弦夹角原理： 向量a=(x1,y1),向量b=(x2,y2) similarity=a.b/|a|*|b| a.b=x1x2+y1y2 * |a|=根号[(x1)^2+(y1)^2],|b|=根号[(x2)^2+(y2)^2] */ public static double getSimilarityImpl(List words1, List words2) { // 向每一个Word对象的属性都注入weight（权重）属性值 taggingWeightByFrequency(words1, words2); //第二步：计算词频 //通过上一步让每个Word对象都有权重值，那么在封装到map中（key是词，value是该词出现的次数（即权重）） Map weightMap1 = getFastSearchMap(words1); Map weightMap2 = getFastSearchMap(words2); //将所有词都装入set容器中 Set words = new HashSet(); words.addAll(words1); words.addAll(words2); AtomicFloat ab = new AtomicFloat();// a.b AtomicFloat aa = new AtomicFloat();// |a|的平方 AtomicFloat bb = new AtomicFloat();// |b|的平方 // 第三步：写出词频向量，后进行计算 words.parallelStream().forEach(word -> { //看同一词在a、b两个集合出现的此次 Float x1 = weightMap1.get(word.getName()); Float x2 = weightMap2.get(word.getName()); if (x1 != null && x2 != null) { //x1x2 float oneOfTheDimension = x1 * x2; //+ ab.addAndGet(oneOfTheDimension); } if (x1 != null) { //(x1)^2 float oneOfTheDimension = x1 * x1; //+ aa.addAndGet(oneOfTheDimension); } if (x2 != null) { //(x2)^2 float oneOfTheDimension = x2 * x2; //+ bb.addAndGet(oneOfTheDimension); } }); //|a| 对aa开方 double aaa = Math.sqrt(aa.doubleValue()); //|b| 对bb开方 double bbb = Math.sqrt(bb.doubleValue()); //使用BigDecimal保证精确计算浮点数 //double aabb = aaa * bbb; BigDecimal aabb = BigDecimal.valueOf(aaa).multiply(BigDecimal.valueOf(bbb)); //similarity=a.b/|a|*|b| //divide参数说明：aabb被除数,9表示小数点后保留9位，最后一个表示用标准的四舍五入法 double cos = BigDecimal.valueOf(ab.get()).divide(aabb, 9, BigDecimal.ROUND_HALF_UP).doubleValue(); return cos; } /** * 向每一个Word对象的属性都注入weight（权重）属性值 */ protected static void taggingWeightByFrequency(List words1, List words2) { if (words1.get(0).getWeight() != null && words2.get(0).getWeight() != null) { return; } //词频统计（key是词，value是该词在这段句子中出现的次数） Map frequency1 = getFrequency(words1); Map frequency2 = getFrequency(words2); //如果是DEBUG模式输出词频统计信息 // if (LOGGER.isDebugEnabled()) { // LOGGER.debug("词频统计1：n{}", getWordsFrequencyString(frequency1)); // LOGGER.debug("词频统计2：n{}", getWordsFrequencyString(frequency2)); // } // 标注权重（该词出现的次数） words1.parallelStream().forEach(word -> word.setWeight(frequency1.get(word.getName()).floatValue())); words2.parallelStream().forEach(word -> word.setWeight(frequency2.get(word.getName()).floatValue())); } /** * 统计词频 * @return 词频统计图 */ private static Map getFrequency(List words) { Map freq = new HashMap(); //这步很帅哦 words.forEach(i -> freq.computeIfAbsent(i.getName(), k -> new AtomicInteger()).incrementAndGet()); return freq; } /** * 输出：词频统计信息 */ private static String getWordsFrequencyString(Map frequency) { StringBuilder str = new StringBuilder(); if (frequency != null && !frequency.isEmpty()) { AtomicInteger integer = new AtomicInteger(); frequency.entrySet().stream().sorted((a, b) -> b.getValue().get() - a.getValue().get()).forEach( i -> str.append("t").append(integer.incrementAndGet()).append("、").append(i.getKey()).append("=") .append(i.getValue()).append("n")); } str.setLength(str.length() - 1); return str.toString(); } /** * 构造权重快速搜索容器 */ protected static Map getFastSearchMap(List words) { if (CollectionUtils.isEmpty(words)) { return Collections.emptyMap(); } Map weightMap = new ConcurrentHashMap(words.size()); words.parallelStream().forEach(i -> { if (i.getWeight() != null) { weightMap.put(i.getName(), i.getWeight()); } else { LOGGER.error("no word weight info:" + i.getName()); } }); return weightMap; } }

这个具体实现代码因为思维很紧密所以有些地方写的比较绕，同时还手写了AtomicFloat原子类。

6、AtomicFloat原子类

import java.util.concurrent.atomic.AtomicInteger; /** * jdk没有AtomicFloat，写一个 */ public class AtomicFloat extends Number { private AtomicInteger bits; public AtomicFloat() { this(0f); } public AtomicFloat(float initialValue) { bits = new AtomicInteger(Float.floatToIntBits(initialValue)); } //叠加 public final float addAndGet(float delta) { float expect; float update; do { expect = get(); update = expect + delta; } while (!this.compareAndSet(expect, update)); return update; } public final float getAndAdd(float delta) { float expect; float update; do { expect = get(); update = expect + delta; } while (!this.compareAndSet(expect, update)); return expect; } public final float getAndDecrement() { return getAndAdd(-1); } public final float decrementAndGet() { return addAndGet(-1); } public final float getAndIncrement() { return getAndAdd(1); } public final float incrementAndGet() { return addAndGet(1); } public final float getAndSet(float newValue) { float expect; do { expect = get(); } while (!this.compareAndSet(expect, newValue)); return expect; } public final boolean compareAndSet(float expect, float update) { return bits.compareAndSet(Float.floatToIntBits(expect), Float.floatToIntBits(update)); } public final void set(float newValue) { bits.set(Float.floatToIntBits(newValue)); } public final float get() { return Float.intBitsToFloat(bits.get()); } @Override public float floatValue() { return get(); } @Override public double doubleValue() { return (double) floatValue(); } @Override public int intValue() { return (int) get(); } @Override public long longValue() { return (long) get(); } @Override public String toString() { return Float.toString(get()); } }

三、总结

把大致思路再捋一下：

（1）先分词：分词当然要按一定规则，不然随便分那也没有意义，那这里通过采用HanLP中文自然语言处理中标准分词进行分词。

（2）统计词频：就统计上面词出现的次数。

（3）通过每一个词出现的次数，变成一个向量，通过向量公式计算相似率。

KNN cosine 余弦相似度计算

# coding: utf-8
import collections
import numpy as np
import os
from sklearn.neighbors import NearestNeighbors


def cos(vector1,vector2):
    dot_product = 0.0;
    normA = 0.0;
    normB = 0.0;
    for a,b in zip(vector1,vector2):
        dot_product += a*b
        normA += a**2
        normB += b**2
    if normA == 0.0 or normB==0.0:
        return None
    else:
        return dot_product / ((normA*normB)**0.5)


def iterbrowse(path):
    for home, dirs, files in os.walk(path):
        for filename in files:
            yield os.path.join(home, filename)


def get_data(filename):
    white_verify = []
    with open(filename) as f:
        lines = f.readlines()
        for line in lines:
            a = line.split("\t")
            if len(a) != 78:
                print(line)
                raise Exception("fuck")
            white_verify.append([float(n) for n in a[3:]])
    return white_verify

unwanted_features = {6, 7, 8, 41,42,43,67,68,69,70,71,72,73,74,75}

def get_wanted_data(x):
    return x
    """
    ans = []
    for item in x:
        #row = [data for i, data in enumerate(item) if i+6 in wanted_feature]
        row = [data for i, data in enumerate(item) if i+6 not in unwanted_features]
        ans.append(row)
        #assert len(row) == len(wanted_feature)
        assert len(row) == len(x[0])-len(unwanted_features)
    return ans
    """


if __name__ == "__main__":
    neg_file = "cc_data/black/black_all.txt"
    pos_file = "cc_data/white/white_all.txt"
    X = []
    y = []
    # if os.path.isfile(pos_file):
    #     if pos_file.endswith(''.txt''):
    #         pos_set = np.genfromtxt(pos_file)
    #     elif pos_file.endswith(''.npy''):
    #         pos_set = np.load(pos_file)
    #     X.extend(pos_set)
    #     y += [0] * len(pos_set)
    # print("len of X(white):", len(X))
    if os.path.isfile(neg_file):
        if neg_file.endswith(''.txt''):
            neg_set = np.genfromtxt(neg_file)
        elif neg_file.endswith(''.npy''):
            neg_set = np.load(neg_file)
        X.extend(list(neg_set) * 1)
        y += [1] * (1 * len(neg_set))
    print("len of X:", len(X))
    # print("X sample:", X[:3])
    # print("len of y:", len(y))
    # print("y sample:", y[:3])
    X = [x[3:] for x in X]
    X = get_wanted_data(X)
    # print("filtered X sample:", X[:3])

    black_verify = []
    for f in iterbrowse("todo/top"):
        print(f)
        black_verify += get_data(f)
    # print(black_verify)
    black_verify = get_wanted_data(black_verify)
    black_verify_labels = [1] * len(black_verify)

    white_verify = get_data("todo/white_verify.txt")
    # print(white_verify)
    white_verify = get_wanted_data(white_verify)
    white_verify_labels = [0] * len(white_verify)

    unknown_verify = get_data("todo/pek_feature74.txt")
    unknown_verify = get_wanted_data(unknown_verify)

    bd_verify = get_data("guzhaoshen_pek_out.txt")
    # print(unknown_verify)

    # samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
    #neigh = NearestNeighbors(n_neighbors=3)
    neigh = NearestNeighbors(n_neighbors=1, metric=''cosine'')
    neigh.fit(X)

    print("neigh.kneighbors(black_verify)")
    nearest_points = (neigh.kneighbors(black_verify))
    print(nearest_points)
    for i, x in enumerate(black_verify):
        print(i, nearest_points[1][i], "cosine:", cos(x, nearest_points[1][i]))

    #print(neigh.predict(black_verify))
    print("neigh.kneighbors(white_verify)")
    nearest_points = (neigh.kneighbors(white_verify))
    print(nearest_points)
    for i, x in enumerate(white_verify):
        print(i, nearest_points[1][i], "cosine:", cos(x, nearest_points[1][i]))

    #print(neigh.predict(white_verify))
    print("neigh.kneighbors(unknown_verify)")
    nearest_points = (neigh.kneighbors(unknown_verify))
    print(nearest_points)
    for i, x in enumerate(unknown_verify):
        print(i, nearest_points[1][i], "cosine:", cos(x, nearest_points[1][i]))

    #print(neigh.predict(unknown_verify))
    print("neigh.kneighbors(self)")
    print(neigh.kneighbors(X[:3]))

    #print(neigh.predict(X[:3]))
    print("neigh.kneighbors(bd pek)")
    print(neigh.kneighbors(bd_verify))

    nearest_points = (neigh.kneighbors(bd_verify))
    print(nearest_points)
    for i, x in enumerate(bd_verify):
        print(i, nearest_points[1][i], "cosine:", cos(x, nearest_points[1][i]))

 输出示例：

neigh.kneighbors(white_verify)
(array([[ 0.01140831],
       [ 0.0067373 ],
       [ 0.00198682],
       [ 0.00686728],
       [ 0.00210445],
       [ 0.00061413],
       [ 0.00453888]]), array([[11032],
       [  967],
       [11091],
       [13149],
       [11091],
       [19041],
       [13068]]))
(0, array([11032]), ''cosine:'', 1.0)
(1, array([967]), ''cosine:'', 1.0)
(2, array([11091]), ''cosine:'', 1.0)
(3, array([13149]), ''cosine:'', 1.0)
(4, array([11091]), ''cosine:'', 1.0)
(5, array([19041]), ''cosine:'', 1.0)
(6, array([13068]), ''cosine:'', 1.0)

样本质量堪忧啊！！！

注意：如果是常规knn，计算距离时候记得标准化。如果各个维度的数据属性衡量单位不一样：

from sklearn import preprocessing
    scaler = preprocessing.StandardScaler().fit(X)
    X = scaler.transform(X)
    print("standard X sample:", X[:3])

    black_verify = scaler.transform(black_verify)
    print(black_verify)

    white_verify = scaler.transform(white_verify)
    print(white_verify)

    unknown_verify = scaler.transform(unknown_verify)
    print(unknown_verify)

关于Python-给定2个句子字符串，计算余弦相似度和python两个字符串匹配的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于C# Net 比较2个字符串的相似度（使用余弦相似度）、java – 如何有效地计算数百万字符串之间的余弦相似度、java算法之余弦相似度计算字符串相似率、KNN cosine 余弦相似度计算等相关内容，可以在本站寻找。

以上就是给各位分享如何计算java.awt.geom.Area的面积？，其中也会对java怎么算面积进行解释，同时本文还将给你拓展CAD2007如何计算面积？CAD2007计算面积方法、CAD如何计算图形面积？cad计算图纸面积方法、Java AWT / SWT / Swing：如何计划GUI？、java – 如何计算JTextArea中的行数,包括由包装引起的行数？等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

• 如何计算java.awt.geom.Area的面积？（java怎么算面积）
• CAD2007如何计算面积？CAD2007计算面积方法
• CAD如何计算图形面积？cad计算图纸面积方法
• Java AWT / SWT / Swing：如何计划GUI？
• java – 如何计算JTextArea中的行数,包括由包装引起的行数？

如何计算java.awt.geom.Area的面积？（java怎么算面积）

我正在寻找一种方法来计算的任意实例的面积（以像素为单位）java.awt.geom.Area。

背景：我Shape的应用程序中可能存在可能重叠的。我想知道一个Shape重叠的部分。的ShapeS可以是歪斜的，旋转，等等。如果我有一个函数area(Shape)（或Area），我可以使用的两个交叉点Shape就像这样：

double fractionObscured(Shape bottom, Shape top) {    Area intersection = new Area(bottom);    intersection.intersect(new Area(top));    return area(intersection) / area(bottom);}

答案1

一种方法是使用合适的方法fill()分别缩放和变换
Shape为不同的颜色，AlphaComposite并计算基础像素中的重叠像素Raster。

附录1：使用此计算器查看效果，AlphaComposite.Xor表明任意两种不透明颜色的间隔为零。

附录2：计数像素可能会导致性能问题；采样可能会有所帮助。如果每个
Shape都是合理凸的，则有可能根据intersect()面积与Shapes’
的面积之和的比率来估计重叠getBounds2D()。例如，

Shape s1, s2 ...Rectangle2D r1 = s1.getBounds2D();Rectangle2D r2 = s2.getBounds2D();Rectangle2D r3 = new Rectangle2D.Double();Rectangle2D.intersect(r1, r2, r3);double overlap = area(r3) / (area(r1) + area(r2));...private double area(Rectangle2D r) {    return r.getWidth() * r.getHeight();}

您可能需要凭经验验证结果。

CAD2007如何计算面积？CAD2007计算面积方法

大家都知道AutoCAD2007是一款非常专业的绘图软件，为经常跟工程打交道的同事们，肯定每天必须接触到CAD，现在CAD版本很多，而大多数的工程师们还是喜欢用2007版本的，当然是它最经典，最兼容，最好用了。计算面积是一个特别常见的做法。图形若是规则就不必费很多力气，不规则的话很多人就不知道怎么下手了。那么如何在cad2007中计算不规则图形面积?下面为大家详细介绍CAD2007计算面积方法，一起来看看吧!

方法/步骤

1、打开CAD2007软件，选择CAD经典模式。

2、在菜单栏里选择打开，或者直接快捷键“ctrl+o”，选择图纸。以我的图纸为例。

3、如果你的图形有图层，并且图层可以选中的话，你可以直接单击图层，然后点击菜单栏里的“工具”——“查询”——“列表显示”，就可以看到面积了。

4、如果没有图层，但是图形是比较规则的，那我们可以通过公式来查询面积。在命令框输入“aa”，回车，然后依次点击图形的端点，使之封闭，最后鼠标右键确定就会显示面积。

5、如果图形不规则，那我们可以用合成多段线和画多段线来解决。合成多段线的命令是“pe”，之后再输入“m”，然后选择图形的边，右键确定，接着Y——J——0，这样多段线合成了，再通过第二种方法查询面积即可。

6、绘制多段线是另一种办法。点左侧菜单栏的“多段线”，然后依次单击图形端点，使之封闭，最后依旧是利用第二种办法查询面积。

以上就是CAD2007计算面积方法介绍，希望对大家有所帮助!

CAD如何计算图形面积？cad计算图纸面积方法

众所周知，CAD是一款实用的制图工具，常用于建筑图纸设计，室内设计，很多工程相关职业都要会使用CAD制图，要会看懂CAD图片。那么给你一张室内设计图，你会用AutoCAD工具来测量面积吗?CAD怎么算面积?下面，我们就一起来看看CAD计算面积图文教程详解。

一、查询命令

1、CAD各个版本操作基本一致，这里以CAD2014为例。对于简单图形，使用简单的查询就能搞定。具体方法是，打开cad图形，在菜单栏，点击“ 工具 ”。

2、调出工具选项，用鼠标指着“ 查询Q ”，激活查询命令。

3、弹出查询的更多功能选项，点击“ 面积 ”。

4、这时候使用鼠标拾取需要查询的围成面积的各个关键点。

5、拾取各个点，围成一个 封闭图形。

6、点击“ 回车键 ”，这时候就直接弹出面积信息，这里的面积一般是以mm为单位的，所以要转化成自己习惯的平方米，小数点向左移动6位即可看出面积。

二、复杂图形的面积查询

1、对于简单图形，按照刚才的方式查询感觉差不多，但是对于不规则的多边形，拾取点将会花费很多时间，这样效率低下，这时候如果觉得费时间，可以创建面域，然后点击“ 工具 ”——“ 查询”——“ 面积 ”中进行查看。

Java AWT / SWT / Swing：如何计划GUI？

我已经实现了一些带有小型图形用户界面的应用程序。没什么复杂的，但是我遇到了一些问题，这些问题导致组件无法显示或无法正常运行。

现在我的问题是：

您如何计划这些用户界面？当您需要进行更改时该怎么办？您如何调试奇怪的行为？

这几乎适用于所有类型的GUI设计。当然，使用Microsoft Visual Studio具有很大的优势，因为您几乎获得了在设计器中看到的东西。

是否存在 优秀 的AWT开源设计器？已经环顾四周，没有发现任何真正聪明的东西。

编辑： 到目前为止，我还手动创建了所有GUI。当然，这是更简洁的代码，但有时很难找到布局错误。如果Visual Studio by
MS能够创建近似干净的代码，那么其他人为什么不呢？

我听说过一些Eclipse Visual设计器。那个已经准备好生产了吗？

答案1

我不是GUI建设者的忠实拥护者：他们通常会自动生成大量的代码，然后将您的整个开发团队锁定为使用一个IDE。而且，此代码通常不可读（请检查在Netbeans下使用Matisse时生成的代码）。

我对GUI设计/调试的建议是：

• main在每个面板（或“顶级”组件）实现中添加一个方法，使其他开发人员可以轻松确定组件的外观。
• 赞成使用Actions over ActionListeners并在每个JComponents中注册这些动作ActionMap。这允许它们被“提取”并添加到UI的其他部分（例如JToolBar），同时它们的状态仍由“所有权” JComponent（即松散耦合）控制。
• 使用assert来确保所有UI组件修改都在Event Dispatch线程上进行；例如assert SwingUtilities.isEventDispatchThread()。
• 要调试奇怪的布局行为，请考虑将组件的背景涂成红色！
• 集中捕获和报告工作流事件和异常。例如，我通常实现一个TaskManager在UI的状态栏中注册的类。任何后台处理（在SwingWorkers 内执行）都会通过传递给Task创建的句柄TaskManager。与工作Interracting（通过调用setDescription(String)，setThrowable(Throwable)，cancel()）导致要更新的状态栏。这也将导致玻璃窗格显示为“全局”任务…但是，所有窗格都与单个SwingWorkers分离/隐藏了。
• 不要使用Observer/ Observable班，而是青睐ChangeListener，PropertyChangeListener或传播事件自己定制的监听器实现。 Observer传递一个Objectas事件，迫使客户端代码使用instanceof检查类型并执行向下转换，使代码不可读并且使类之间的关系不那么清楚。
• 即使在表只有一列的情况下，也建议使用JTableover JList。 JList它的API中有一些讨厌的功能，包括您需要为其提供原型值以正确计算其大小这一事实。
• 永远不要使用DefaultTableModel它，因为它通常会导致您将“模型”数据存储在两个位置：在实际的业务对象中以及位于2D数组中DefaultTableModel。相反，只需子类AbstractTableModel-这 很容易 做到，并且意味着您的实现可以简单地委派给List存储您的数据的数据结构（例如）。

java – 如何计算JTextArea中的行数,包括由包装引起的行数？

Font font = jTextArea.getFont();
  FontMetrics fontMetrics = jTextArea.getFontMetrics(font);
  int lineHeight = fontMetrics.getAscent() + fontMetrics.getDescent();

package components;                                                                           

import java.awt.*;
import java.awt.event.*;
import java.awt.font.*;
import java.text.*;
import javax.swing.*;

public class JTextAreaLineCountDemo extends JPanel {                                          
  JTextArea textArea;                                                                         

  public JTextAreaLineCountDemo() {                                                           
    super(new GridBagLayout());                                                               

    String inputStr = "Lorem ipsum dolor sit amet,consectetur adipisicing elit,sed do eiusmo";
    textArea = new JTextArea(inputStr);                                                       
    textArea.setEditable(false);                                                              
    textArea.setLineWrap(true);                                                               
    textArea.setWrapStyleWord(true);                                                          

    // Add Components to this panel.                                                          
    GridBagConstraints c = new GridBagConstraints();                                          
    c.gridwidth = GridBagConstraints.REMAINDER;                                               

    c.fill = GridBagConstraints.BOTH;                                                         
    c.weightx = 1.0;                                                                          
    c.weighty = 1.0;                                                                          
    add(textArea,c);                                                                         

    addComponentListener(new ComponentAdapter() {                                             
      @Override                                                                               
      public void componentResized(ComponentEvent ce) {                 
        System.out.println("Line count: " + countLines(textArea));                         
      }                                                                                       
    });                                                                                       
  }                                                                                           

  private static int countLines(JTextArea textArea) {
    AttributedString text = new AttributedString(textArea.getText());
    FontRenderContext frc = textArea.getFontMetrics(textArea.getFont())
        .getFontRenderContext();
    AttributedCharacterIterator charIt = text.getIterator();
    LineBreakMeasurer lineMeasurer = new LineBreakMeasurer(charIt,frc);
    float formatWidth = (float) textArea.getSize().width;
    lineMeasurer.setPosition(charIt.getBeginIndex());

    int noLines = 0;
    while (lineMeasurer.getPosition() < charIt.getEndindex()) {
      lineMeasurer.nextLayout(formatWidth);
      noLines++;
    }

    return noLines;
  }

  private static void createAndShowGUI() {                                                    
    JFrame frame = new JFrame("JTextAreaLineCountDemo");                                      
    frame.setDefaultCloSEOperation(JFrame.EXIT_ON_CLOSE);                                     

    frame.add(new JTextAreaLineCountDemo());                                                  

    frame.pack();                                                                             
    frame.setVisible(true);                                                                   
  }                                                                                           

  public static void main(String[] args) {                                                    
    javax.swing.SwingUtilities.invokelater(new Runnable() {                                   
      public void run() {                                                                     
        createAndShowGUI();                                                                   
      }                                                                                       
    });                                                                                       
  }                                                                                           
}

关于如何计算java.awt.geom.Area的面积？和java怎么算面积的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于CAD2007如何计算面积？CAD2007计算面积方法、CAD如何计算图形面积？cad计算图纸面积方法、Java AWT / SWT / Swing：如何计划GUI？、java – 如何计算JTextArea中的行数,包括由包装引起的行数？的相关知识，请在本站寻找。

本文将分享计算复活节星期天的日期的详细内容，并且还将对计算复活节星期天的日期怎么算进行详尽解释，此外，我们还将为大家带来关于AngularJS：明天的日期和昨天的某个ng组件的日期、iOS 获取本周星期一至星期日的日期、iOS：获取一周7天的日期（年-月-日-星期）、java 计算当前日期所在周的星期一及星期日的日期的相关知识，希望对你有所帮助。

• 计算复活节星期天的日期（计算复活节星期天的日期怎么算）
• AngularJS：明天的日期和昨天的某个ng组件的日期
• iOS 获取本周星期一至星期日的日期
• iOS：获取一周7天的日期（年-月-日-星期）
• java 计算当前日期所在周的星期一及星期日的日期

计算复活节星期天的日期（计算复活节星期天的日期怎么算）

编写一个程序来计算复活节星期天的日期。复活节星期日是春天的第一个满月之后的第一个星期日。使用数学家卡尔·弗里德里希·高斯（Carl Friedrich
Gauss）在1800年发明的算法：

1. 让y是年份（如1800年或2001年）
2. 除以y通过19并调用剩余a。忽略商。
3. 除以y通过100获得商b和余数c。
4. 除以b通过4获得商d和余数e。
5. 除以8 * b + 13通过25获得商g。忽略其余部分。
6. 除以19 * a + b - d - g + 15通过30得到的余数h。忽略商。
7. 除以c通过4获得商j和余数k。
8. 除以a + 11 * h通过319获得商m。忽略其余部分。
9. 除以2 * e + 2 * j - k - h + m + 32通过7得到的余数r。忽略商。
10. 除以h - m + r + 90通过25获得商n。忽略其余部分。
11. 除以h - m + r + n + 19通过32获得的剩余部分p。忽略商。

然后复活节p是一个月的一天n。

例如，如果y为2001：

a = 6b = 20c = 1d = 5e = 0g = 6h = 18j = 0k = 1m = 0r = 6n = 4p = 15

因此，在2001年，复活节星期日是4月15日。

确保提示用户输入年份并让用户输入年份。另外，请确保输出p和n的值以及描述输出值的适当消息。

将其放入Java代码时遇到了一些麻烦。这是我尝试过的：

import java.util.Scanner;public class Easter {    public static void main(String[] args) {        Scanner input = new Scanner(System.in);        int y = 2014;        int a = y % 19;        int b = y / 100;        int c = y % 100;        int d = b / 4;        int e = b % 4;        int g = (8 * b + 13) / 25;        int h = (19 * a + b - d - g + 15) % 30;        int j = c / 4;        int k = c % 4;        int m = (a + 11 * h) / 319;        int r = (2 * e + 2 * j - k - h + m + 32) % 7;        int n = (h - m + r + 90) / 25;        int p = (h - m + r + n + 19) % 32;        getEasterSundayMonth = n;        System.out.println("Month: " + Easter.getEasterSundayMonth());    }}

这就是我所拥有的。我不知道如何分配内容，就像我试图使getEasterSundayMonth的值相等一样n，很确定它是不正确的。我从这里去哪里？

答案1

试试这个：

import java.util.Scanner;class Easter{    public static void main(String[] args)    {        System.out.print("Please enter a year to calculate Easter Sunday\n>");        Scanner s = new Scanner(System.in);        int inputted = getResult(s);        while(inputted <= 0)        {            System.out.print("Expected a positive year. Please try again:\n>");            inputted = getResult(s);        }        System.out.println(getEasterSundayDate(inputted));    }    private static int getResult(Scanner s)    {        while(!s.hasNextInt())        {            System.out.print("Expected a valid year. Please try again:\n>");            s.nextLine();        }        return s.nextInt();    }    public static String getEasterSundayDate(int year)    {        int a = year % 19,            b = year / 100,            c = year % 100,            d = b / 4,            e = b % 4,            g = (8 * b + 13) / 25,            h = (19 * a + b - d - g + 15) % 30,            j = c / 4,            k = c % 4,            m = (a + 11 * h) / 319,            r = (2 * e + 2 * j - k - h + m + 32) % 7,            n = (h - m + r + 90) / 25,            p = (h - m + r + n + 19) % 32;        String result;        switch(n)        {            case 1:                result = "January ";                break;            case 2:                result = "February ";                break;            case 3:                result = "March ";                break;            case 4:                result = "April ";                break;            case 5:                result = "May ";                break;            case 6:                result = "June ";                break;            case 7:                result = "July ";                break;            case 8:                result = "August ";                break;            case 9:                result = "September ";                break;            case 10:                result = "October ";                break;            case 11:                result = "November ";                break;            case 12:                result = "December ";                break;            default:                result = "error";        }        return result + p;    }}

2001结果的输入April 15作为输出。

AngularJS：明天的日期和昨天的某个ng组件的日期

$scope.date = new Date();   
var tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);

<div ng-app="myApp" ng-controller="myCtrl">
    <p><a href="" ng-click="showToday = true; showTomorrow = false">Left arrow</a></p>
    <p><a href="" ng-click="showTomorrow = true; showToday = false">Right arrow</a></p>
    <span ng-show="showToday">Today: {{date | date:'EEE,dd MMM yyyy'}}</span>
    <span ng-show="showTomorrow">Tomorrow: {{tomorrow | date:'EEE,dd MMM yyyy'}}</span>
</div>

angular.module('myApp',[])
.controller('myCtrl',function ($scope) {
    $scope.showToday = false;
    $scope.showTomorrow = false;
    $scope.date = new Date();   
    $scope.tomorrow = new Date();
    $scope.tomorrow.setDate($scope.tomorrow.getDate() + 1);
});

iOS 获取本周星期一至星期日的日期

NSDate *now = [NSDate date];
NSCalendar *calendar = [NSCalendar currentCalendar];
NSDateComponents *comp = [calendar components:NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit|NSWeekdayCalendarUnit|NSDayCalendarUnit
                                       fromDate:now];  
// 得到星期几// 1(星期天) 2(星期二) 3(星期三) 4(星期四) 5(星期五) 6(星期六) 7(星期天)NSInteger weekDay = [comp weekday];// 得到几号NSInteger day = [comp day];

NSLog(@"weekDay:%ld   day:%ld",weekDay,day);    
// 计算当前日期和这周的星期一和星期天差的天数long firstDiff,lastDiff;if (weekDay == 1) {
    firstDiff = 1;
    lastDiff = 0;
}else{
    firstDiff = [calendar firstWeekday] - weekDay;
    lastDiff = 9 - weekDay;
}

NSLog(@"firstDiff:%ld   lastDiff:%ld",firstDiff,lastDiff);    
// 在当前日期(去掉了时分秒)基础上加上差的天数NSDateComponents *firstDayComp = [calendar components:NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit fromDate:now];
[firstDayComp setDay:day + firstDiff];
NSDate *firstDayOfWeek= [calendar dateFromComponents:firstDayComp];

NSDateComponents *lastDayComp = [calendar components:NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit fromDate:now];
[lastDayComp setDay:day + lastDiff];
NSDate *lastDayOfWeek= [calendar dateFromComponents:lastDayComp];

NSDateFormatter *formater = [[NSDateFormatter alloc] init];
[formater setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
NSLog(@"星期一开始 %@",[formater stringFromDate:firstDayOfWeek]);
NSLog(@"当前 %@",[formater stringFromDate:now]);
NSLog(@"星期天结束 %@",[formater stringFromDate:lastDayOfWeek]);

iOS：获取一周7天的日期（年-月-日-星期）

一、介绍

在开发中，日期的使用绝对是离不了的，跟业务的关联性太强了，例如课程表。有的时候我们不需要课程表，但是需要获取一周7天的日期，这一周内的日期，我觉得有两种理解：

1、获取当天开始的一周日期，当天作为起点往后顺延的一周（红色的为当天），实现方法见如下代码：方式一：

2、获取一周内的日期，当天在这一周内，所在一周的第一天和最后一天, 不是作为起点往后顺延（红色的为当天），实现方法见如下代码：方式二：

二、代码（放在单例工具类HYWeekCalendarUitility实现）

1、工具类声明和实现

@interface HYWeekCalendarUitility : NSObject
@property (nonatomic, strong) NSArray  *weeks;
@property (nonatomic,   copy) NSString *firstDayDeteOfWeek;
@property (nonatomic,   copy) NSString *nowDayDeteOfWeek;
@property (nonatomic,   copy) NSString *lastDayDeteOfWeek;
+ (instancetype)shareInstance;
@end

+ (instancetype)shareInstance {
    static HYWeekCalendarUitility *weekCalendarUitility = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        weekCalendarUitility = [[HYWeekCalendarUitility alloc] init];
        //[weekCalendarUitility getDateWeeksDuraingToday];
        [weekCalendarUitility getDateWeeksFromToday];
    });
    return weekCalendarUitility;
}

-(NSString *)transWeekName:(NSString *)orrignWeekName
{
    NSString *targetWeekName = @"";
    
    //转换文案
    if ([orrignWeekName isEqualToString:@"星期日"]) {
        targetWeekName = @"周日";
    }
    else if ([orrignWeekName isEqualToString:@"星期一"]) {
        targetWeekName = @"周一";
    }
    else if ([orrignWeekName isEqualToString:@"星期二"]) {
        targetWeekName = @"周二";
    }
    else if ([orrignWeekName isEqualToString:@"星期三"]) {
        targetWeekName = @"周三";
    }
    else if ([orrignWeekName isEqualToString:@"星期四"]) {
        targetWeekName = @"周四";
    }
    else if ([orrignWeekName isEqualToString:@"星期五"]) {
        targetWeekName = @"周五";
    }else{
        targetWeekName = @"周六";
    }
    
    return targetWeekName;
}

2、方法实现

---方式一---

/**
 *  模式一
 *  获取当前时间开始的一周日期
 *  注意：当天作为起点往后顺延的一周
 */
-(void)getDateWeeksFromToday{
    
    //日历格式
    NSCalendar *calendar = [NSCalendar currentCalendar];
    NSDateFormatter *formater = [[NSDateFormatter alloc] init];
    [formater setDateFormat:@"yyyy-MM-dd"];
    
    NSMutableArray *dateWeeks = [NSMutableArray array];
    for (int i=0; i<7; i++) {
        //这一天
        NSDateComponents *components = [calendar components:NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay | NSCalendarUnitWeekday fromDate:[NSDate dateWithTimeIntervalSinceNow:60 * 60 * 24 * i]];
        NSDate *date = [calendar dateFromComponents:components];
        
        //年月日
        NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
        [dateFormatter setDateFormat:@"yyyy-MM-dd"];
        NSString *dateString = [dateFormatter stringFromDate:date];//几月几号
        
        //星期
        NSDateFormatter *weekFormatter = [[NSDateFormatter alloc] init];
        [weekFormatter setDateFormat:@"EEEE"];
        NSString *weekString = [self transWeekName:[weekFormatter stringFromDate:date]];//周几
        
        NSString *date_weekStr = [NSString stringWithFormat:@"%@-%@",dateString,weekString];
        [dateWeeks addObject:date_weekStr];
        
        //赋值
        if (i==0) {
            self.firstDayDeteOfWeek = [formater stringFromDate:date];
            self.nowDayDeteOfWeek = [formater stringFromDate:date];
        }else if (i==6) {
            self.lastDayDeteOfWeek = [formater stringFromDate:date];
        }
    }
    
    self.weeks = dateWeeks;
    NSLog(@"----dateWeeks:%@------",dateWeeks);
}

---方式二---

/**
 *  模式二
 *  获取当前时间所在一周的第一天和最后一天, 也即一周的日期
 *  注意：当天在这一周内，不是作为起点往后顺延
 */
- (void)getDateWeeksDuraingToday
{
    //日历格式
    NSDate *now = [NSDate date];
    NSCalendar *calendar = [NSCalendar currentCalendar];
    NSDateComponents *comp = [calendar components:NSCalendarUnitYear|NSCalendarUnitMonth|NSCalendarUnitDay|NSCalendarUnitWeekday
                                         fromDate:now];
    // 得到：今天是星期几
    // 1(星期天) 2(星期二) 3(星期三) 4(星期四) 5(星期五) 6(星期六) 7(星期天)
    NSInteger weekDay = [comp weekday];
    // 得到：今天是几号
    NSInteger day = [comp day];
    
    NSLog(@"weekDay:%ld  day:%ld",weekDay,day);
    
    // 计算当前日期和这周的星期一和星期天差的天数
    long firstDiff,lastDiff;
    if (weekDay == 1) {
        firstDiff = 1;
        lastDiff = 0;
    }else{
        firstDiff = [calendar firstWeekday] - weekDay;
        lastDiff = 7 - weekDay;
    }
    NSLog(@"firstDiff:%ld   lastDiff:%ld",firstDiff,lastDiff);
    
    // 一周日期
    NSArray *dateWeeks = [self getCurrentWeeksWithFirstDiff:firstDiff lastDiff:lastDiff];
    
    // 在当前日期(去掉了时分秒)基础上加上差的天数
    NSDateComponents *firstDayComp = [calendar components:NSCalendarUnitYear|NSCalendarUnitMonth|NSCalendarUnitDay fromDate:now];
    [firstDayComp setDay:day + firstDiff];
    NSDate *firstDayOfWeek= [calendar dateFromComponents:firstDayComp];
    
    NSDateComponents *lastDayComp = [calendar components:NSCalendarUnitYear|NSCalendarUnitMonth|NSCalendarUnitDay fromDate:now];
    [lastDayComp setDay:day + lastDiff];
    NSDate *lastDayOfWeek= [calendar dateFromComponents:lastDayComp];
    
    NSDateFormatter *formater = [[NSDateFormatter alloc] init];
    [formater setDateFormat:@"yyyy-MM-dd"];
    NSLog(@"一周开始 %@",[formater stringFromDate:firstDayOfWeek]);
    NSLog(@"当前 %@",[formater stringFromDate:now]);
    NSLog(@"一周结束 %@",[formater stringFromDate:lastDayOfWeek]);
    
    NSLog(@"%@",dateWeeks);
    
    self.firstDayDeteOfWeek = [formater stringFromDate:firstDayOfWeek];
    self.nowDayDeteOfWeek = [formater stringFromDate:now];
    self.lastDayDeteOfWeek = [formater stringFromDate:lastDayOfWeek];
    self.weeks = dateWeeks;
}

//获取一周时间 数组
- (NSMutableArray *)getCurrentWeeksWithFirstDiff:(NSInteger)first lastDiff:(NSInteger)last{
    
    NSMutableArray *eightArr = [[NSMutableArray alloc] init];
    for (NSInteger i = first; i < last + 1; i ++) {
        //从现在开始的24小时
        NSTimeInterval secondsPerDay = i * 24*60*60;
        NSDate *curDate = [NSDate dateWithTimeIntervalSinceNow:secondsPerDay];                NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
        [dateFormatter setDateFormat:@"yyyy-MM-dd"];
        NSString *dateStr = [dateFormatter stringFromDate:curDate];//几月几号
        //NSString *dateStr = @"5月31日";
        NSDateFormatter *weekFormatter = [[NSDateFormatter alloc] init];
        [weekFormatter setDateFormat:@"EEEE"];//星期几 @"HH:mm ''on'' EEEE MMMM d"];
        NSString *weekStr = [weekFormatter stringFromDate:curDate];
        
        //转换文案
        weekStr = [self transWeekName:weekStr];
        
        //组合时间
        NSString *strTime = [NSString stringWithFormat:@"%@-%@",dateStr,weekStr];
        [eightArr addObject:strTime];
        
    }
    return eightArr;
}

java 计算当前日期所在周的星期一及星期日的日期

public static void mondayToSunday() {
  Date now = new Date();
  Date time = new Date(now.getYear(), now.getMonth(), now.getDate());
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 设置时间格式
  Calendar cal = Calendar.getInstance();
  cal.setTime(time);
  // 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
  int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
  if (1 == dayWeek) {
   cal.add(Calendar.DAY_OF_MONTH, -1);
  }
  System.out.println("要计算日期为:" + sdf.format(cal.getTime())); // 输出要计算日期
  // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
  cal.setFirstDayOfWeek(Calendar.MONDAY);
  // 获得当前日期是一个星期的第几天
  int day = cal.get(Calendar.DAY_OF_WEEK);
  // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
  cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
  cal.set(Calendar.HOUR, 0);
  cal.set(Calendar.MINUTE, 0);
  cal.set(Calendar.SECOND, 0);
  String imptimeBegin = sdf.format(cal.getTime());
  Date mondayDate = cal.getTime();
  System.out.println("所在周星期一的日期：" + imptimeBegin);
  cal.add(Calendar.DATE, 6);
  cal.set(Calendar.HOUR, 23);
  cal.set(Calendar.MINUTE, 59);
  cal.set(Calendar.SECOND, 59);
  String imptimeEnd = sdf.format(cal.getTime());
  Date sundayDate = cal.getTime();
  System.out.println("所在周星期日的日期：" + imptimeEnd);
  DateFormat datetimeDf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  System.out.println("星期一的开始：" + datetimeDf.format(mondayDate));
  System.out.println("星期天的结束：" + datetimeDf.format(sundayDate));
 }

关于计算复活节星期天的日期和计算复活节星期天的日期怎么算的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于AngularJS：明天的日期和昨天的某个ng组件的日期、iOS 获取本周星期一至星期日的日期、iOS：获取一周7天的日期（年-月-日-星期）、java 计算当前日期所在周的星期一及星期日的日期等相关知识的信息别忘了在本站进行查找喔。